Recently I got curious to explore the methods that are available to find out a file's size in C++. The first (easiest?) method that I had learned a long time ago is using tellg(). Let's see an example:

#include <iostream>
#include <fstream>

using namespace std;

int main() {

    ifstream file("test", ios::ate);
    streampos size = file.tellg();
    cout<<"File size for \"test\" is: "<<size<<" bytes."<<endl;

    return 0;
}

Simple. First, a file stream is opened with ios::ate flag which sets the stream's position indicator at the end of the file. Then, tellg() is used to retrieve this position index.
Back then, this was the only method I used to find a file's size. However, in some cases it would be handy to be able to retrieve a file's size without having to open the file. Other than that, some say that if the file has been opened in binary mode, sometimes the returned size could be incorrect(?).
Whether the latter fact is true or not, opening a file just to determine it's size doesn't seem to be the best approach. What other method is available, then?

An alternative approach is to use the stat struct. Let's see it in action:

#include <iostream>
#include <sys/stat.h>

using namespace std;

int main() {

    struct stat st;
    stat("test", &st);
    cout<<"File size for \"test\" is: "<<st.st_size<<" bytes."<<endl;

    return 0;
}

I know! struct stat st; looks like C! In C++ you don't need to write struct every time you want to declare a structure instance. However, notice that in <sys/stat.h>, there is also a function with the same name. Without the extra struct in front of it, the compiler comes up with an error because it mistakenly tries to consider the function.
The stat method works without the need to open the file. However, your code becomes platform-dependent to some degree. The stat function and struct are available in POSIX-based systems. In Windows, however, the equivalent is _stat. Given that, it's not difficult to write a function that works on both platforms alike, with a little bit of macro help:

#include <iostream>
#include <string>
#include <stdexcept>
#include <sys/stat.h>

long int file_size(const std::string& file_name) {
    #if defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))
        #define STAT_IDENTIFIER stat //for MacOS X and other Unix-like systems
    #elif defined(_WIN32)
        #define STAT_IDENTIFIER _stat //for Windows systems, both 32bit and 64bit?
    #endif
    struct STAT_IDENTIFIER st;
    if(STAT_IDENTIFIER(file_name.c_str(), &st) == -1) {
        throw std::runtime_error("stat error!");
    }
    return st.st_size;
}

using namespace std;

int main() {

    try {
        cout<<"File size for \"test\" is: "<<file_size("test")<<" bytes."<<endl;
    } catch(const exception& e) {
        cerr<<e.what()<<endl;
    }

    return 0;
}

If you check Boost's filesystem library, you will find it's file_size function is using the stat approach. Until a filesystem library is added to the C++ standard (hopefully!), the better approach to determine a file's size seems to be the stat method, whether you use Boost or a function like above.

It would be interesting for me to see if the above code works in Visual Studio and Mac OS X as well, as the only platform I currently have access to is GNU/Linux. Please share your result if you test it.

Reference on macros used: here