Chad has given a pretty good dictionary definition. Forward declarations are often used in C++ to deal with circular relationships. For example: class B; // Forward declaration class A { B* b; }; class B { A* a; };
To combine several answers and add my own, without a class definition the calling code doesn’t know: whether the class has a declared destructor, or if the default destructor is to be used, and if so whether the default destructor is trivial, whether the destructor is accessible to the calling code, what base classes exist … Read more
It’s so you can declare, in your own headers, methods that rely on the declarations of iostream types without having to #include the iostream headers themselves, which are large, complex and slow to compile against. Here’s a simple example: // foo.h #include <iosfwd> void sucker(std::iostream& is); // foo.cc #include <iostream> void sucker(std::iostream& is) { … Read more
A forward declaration is only really useful for telling the compiler that a class with that name does exist and will be declared and defined elsewhere. You can’t use it in any case where the compiler needs contextual information about the class, nor is it of any use to the compiler to tell it only … Read more
Move doSomething definition outside of its class declaration and after B and also make add accessible to A by public-ing it or friend-ing it. class B; class A { void doSomething(B * b); }; class B { public: void add() {} }; void A::doSomething(B * b) { b->add(); }
As of the LLVM Compiler version shipped with Xcode 4.3, if you try to call a method that the compiler has not previously seen, it will look in the rest of the current @implementation block to see if that method has been declared later. If so, then it uses that, and you don’t get a … Read more
It’s explicitly legal. The rule is that the types used to instantiate a template in the standard library must be complete, unless otherwise specified. In the case of unique_ptr, §20.7.1/5 says “[…] The template parameter T of unique_ptr may be an incomplete type.” There are certain operations on the pointer which require a complete type; … Read more
The forward-declaration method is almost always better. (I can’t think of a situation where including a file where you can use a forward declaration is better, but I’m not gonna say it’s always better just in case). There are no downsides to forward-declaring classes, but I can think of some downsides for including headers unnecessarily: … Read more
Wrap the invocation into a function of its own so that foo() def foo(): print “Hi!” will break, but def bar(): foo() def foo(): print “Hi!” bar() will work properly. The general rule in Python is that a function should be defined before its usage, which does not necessarily mean it needs to be higher … Read more
What you can do is to wrap the invocation into a function of its own. So that foo() def foo(): print “Hi!” will break, but def bar(): foo() def foo(): print “Hi!” bar() will be working properly. General rule in Python is not that function should be defined higher in the code (as in Pascal), … Read more