You can open the file using the ios::ate flag (and ios::binary flag), so the tellg() function will directly give you directly the file size: ifstream file( “example.txt”, ios::binary | ios::ate); return file.tellg();
How about this :- std::ifstream inFile(“file”); std::count(std::istreambuf_iterator<char>(inFile), std::istreambuf_iterator<char>(), ‘\n’);
You can use relative paths as well. But they are relative to the environment you call your executable from. This is OS dependent but all the major systems behave more or less the same AFAIK. Windows example: // File structure: c:\folder\myprogram.exe c:\myfile.txt // Calling command from folder c:\folder > myprogram.exe In the above example you … Read more
If you simply open the file for writing with the truncate-option, you’ll delete the content. std::ofstream ofs; ofs.open(“test.txt”, std::ofstream::out | std::ofstream::trunc); ofs.close(); http://www.cplusplus.com/reference/fstream/ofstream/open/
As @Mgetz says, you probably forgot to #include <fstream>. The reason you didn’t get a not declared error and instead this incomplete type not allowed error has to do with what happens when there is a type that has been “forward declared”, but not yet fully defined. Look at this example: #include <iostream> struct Foo; … Read more
You’re missing #include <fstream> and you probably assign somthing to inFile which is not allowed.
No, that is not possible, not at least in the Standard conformant implementation of the library. The fstream class doesn’t store the filename, and doesn’t provide any function for retrieving it. So one way to keep track of this information is to use std::map as: std::map<std::fstream*, std::string> stream_file_table; void f() { //when you open a … Read more
The term stream is an abstraction of a construct that allows you to send or receive an unknown number of bytes. The metaphor is a stream of water. You take the data as it comes, or send it as needed. Contrast this to an array, for example, which has a fixed, known length. Examples where … Read more
This is basically due to function call overhead and indirection. The ofstream::write() method is inherited from ostream. That function is not inlined in libstdc++, which is the first source of overhead. Then ostream::write() has to call rdbuf()->sputn() to do the actual writing, which is a virtual function call. On top of that, libstdc++ redirects sputn() … Read more
I think the previous answers are misleading. fstream is a proper RAII object, it does close automatically at the end of the scope, and there is absolutely no need whatsoever to call close manually when closing at the end of the scope is sufficient. In particular, it’s not a “best practice” and it’s not necessary … Read more