forward declare static function c++

I want to forward declare a static member function of a class in another file. What I WANT to do looks like this:

BigMassiveHeader.h:

class foo
{
    static void init_foos();
}

Main.cpp:

class foo;
void foo::init_foos();
int main(char** argv, int argc)
{
    foo::init_foos()
}

This fails out with "error C2027: use of undefine开发者_开发百科d type 'foo'"

Is there a way to accomplish what I want to do with out making init_foos a free function, or including BigMassiveHeader.h? (BigMassiveHeader.h is noticeably effecting compile time, and is included everywhere.)

You cannot forward declare members of a class, regardless of whether they are static or not.

You can't forward declare members of your class but you could make a namespace and a function inside of that namespace and forward declare that.

namespace nsfoo
{
     void init_foos();
}

Your class if needed could friend this function.

If you have a BigMassiveHeader, you should consider splitting it up into several SmallCompactHeaders. If you want to express that many classes and functions belong together semantically, you can put them in the same namespace. You can always provide a convenience-header that includes all your small headers.

You can't partially declare classes in C++, so either you'll have to put the class's declaration in its own, smaller header, or...

Include BigMassiveHeader.h in your file and use precompiled headers. The Visual C++ way: http://msdn.microsoft.com/en-us/library/2yzw0wyd%28v=VS.71%29.aspx, or the GCC way: http://gcc.gnu.org/onlinedocs/gcc/Precompiled-Headers.html.

I know it's not the point of the question, but if BigMassiveHeader.h is not likely to change much over time, you should take a look at precompiled headers

As a first refactoring, I'd use a free function which calls the static function. It's not like your main method is getting called lots of times, so you won't notice an extra call, and that makes the least change to the existing code.

Of course, you don't actually say what you are trying to do, only what you want to do. If what you are trying to do is get init_foos called once on application start, use static object initialisation for that, rather than calling it in main. If what you are trying to do is get init_foos called after all static objects are created, then it's more complicated.

By static object initialisation, I mean something like having this in a .cpp file which has access to the definition of init_foos. Make it a friend and init_foos private to prevent multiple calls:

struct call_init_foos {
  call_init_foos () { foo::init_foos(); }
} call_init_foos_on_startup;

to forward declaration of a single method of a class, you must declare the method as part of the class (as it really is).

for example, in your case, add to main.cpp:

class foo
{
public:
    static void init_foos();
}

its not the prettiest, but it will save you having to include the whole header..

No, you need to include the header for that. Sorry.

Use a free function if you must, or split the class.