When can I use a forward declaration?
Put yourself in the compiler's position: when you forward declare a type, all the compiler knows is that this type exists; it knows nothing about its size, members, or methods. This is why it's called an incomplete type. Therefore, you cannot use the type to declare a member, or a base class, since the compiler would need to know the layout of the type.
Assuming the following forward declaration.
class X;
Here's what you can and cannot do.
What you can do with an incomplete type:
Declare a member to be a pointer or a reference to the incomplete type:
class Foo {
X *p;
X &r;
};Declare functions or methods which accept/return incomplete types:
void f1(X);
X f2();Define functions or methods which accept/return pointers/references to the incomplete type (but without using its members):
void f3(X*, X&) {}
X& f4() {}
X* f5() {}
What you cannot do with an incomplete type:
Use it as a base class
class Foo : X {} // compiler error!
Use it to declare a member:
class Foo {
X m; // compiler error!
};Define functions or methods using this type
void f1(X x) {} // compiler error!
X f2() {} // compiler error!Use its methods or fields, in fact trying to dereference a variable with incomplete type
class Foo {
X *m;
void method()
{
m->someMethod(); // compiler error!
int i = m->someField; // compiler error!
}
};
When it comes to templates, there is no absolute rule: whether you can use an incomplete type as a template parameter is dependent on the way the type is used in the template.
For instance, std::vector<T>
requires its parameter to be a complete type, while boost::container::vector<T>
does not. Sometimes, a complete type is required only if you use certain member functions; this is the case for std::unique_ptr<T>
, for example.
A well-documented template should indicate in its documentation all the requirements of its parameters, including whether they need to be complete types or not.
Should one use forward declarations instead of includes wherever possible?
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:
longer compilation time, since all translation units including
C.h
will also includeA.h
, although they might not need it.possibly including other headers you don't need indirectly
polluting the translation unit with symbols you don't need
you might need to recompile source files that include that header if it changes (@PeterWood)
What are forward declarations in C++?
Why forward-declare is necessary in C++
The compiler wants to ensure you haven't made spelling mistakes or passed the wrong number of arguments to the function. So, it insists that it first sees a declaration of 'add' (or any other types, classes, or functions) before it is used.
This really just allows the compiler to do a better job of validating the code and allows it to tidy up loose ends so it can produce a neat-looking object file. If you didn't have to forward declare things, the compiler would produce an object file that would have to contain information about all the possible guesses as to what the function add
might be. And the linker would have to contain very clever logic to try and work out which add
you actually intended to call, when the add
function may live in a different object file the linker is joining with the one that uses add to produce a dll
or exe
. It's possible that the linker may get the wrong add
. Say you wanted to use int add(int a, float b)
, but accidentally forgot to write it, but the linker found an already existing int add(int a, int b)
and thought that was the right one and used that instead. Your code would compile, but wouldn't be doing what you expected.
So, just to keep things explicit and avoid guessing, etc, the compiler insists you declare everything before it is used.
Difference between declaration and definition
As an aside, it's important to know the difference between a declaration and a definition. A declaration just gives enough code to show what something looks like, so for a function, this is the return type, calling convention, method name, arguments, and their types. However, the code for the method isn't required. For a definition, you need the declaration and then also the code for the function too.
How forward-declarations can significantly reduce build times
You can get the declaration of a function into your current .cpp
or .h
file by #includ'ing the header that already contains a declaration of the function. However, this can slow down your compile, especially if you #include
a header into a .h
instead of .cpp
of your program, as everything that #includes the .h
you're writing would end up #include'ing all the headers you wrote #includes for too. Suddenly, the compiler has #included pages and pages of code that it needs to compile even when you only wanted to use one or two functions. To avoid this, you can use a forward-declaration and just type the declaration of the function yourself at the top of the file. If you're only using a few functions, this can really make your compiles quicker compared to always #including the header. For really large projects, the difference could be an hour or more of compile time bought down to a few minutes.
Break cyclic references where two definitions both use each other
Additionally, forward-declarations can help you break cycles. This is where two functions both try to use each other. When this happens (and it is a perfectly valid thing to do), you may #include
one header file, but that header file tries to #include
the header file you're currently writing... which then #includes the other header, which #includes the one you're writing. You're stuck in a chicken and egg situation with each header file trying to re #include the other. To solve this, you can forward-declare the parts you need in one of the files and leave the #include out of that file.
Eg:
File Car.h
#include "Wheel.h" // Include Wheel's definition so it can be used in Car.
#include <vector>
class Car
{
std::vector<Wheel> wheels;
};
File Wheel.h
Hmm... the declaration of Car
is required here as Wheel
has a pointer to a Car
, but Car.h
can't be included here as it would result in a compiler error. If Car.h
was included, that would then try to include Wheel.h
which would include Car.h
which would include Wheel.h
and this would go on forever, so instead the compiler raises an error. The solution is to forward declare Car
instead:
class Car; // forward declaration
class Wheel
{
Car* car;
};
If class Wheel
had methods which need to call methods of Car
, those methods could be defined in Wheel.cpp
and Wheel.cpp
is now able to include Car.h
without causing a cycle.
Forward declare or #include first?
Always headers first, then forward declares. Otherwise you risk unnecessary dependencies such that you'll need to repeat the forward declares whenever you include donna.h, for example (because you have inadvertently introduced a need for it).
What is the difference between forward declaration and forward reference?
From Wikipedia:
Forward Declaration
Declaration of a variable or function which are not defined yet. Their defnition can be seen later on.
Forward Reference
Similar to Forward Declaration but where the variable or function appears first the definition is also in place.
Forward declaration / when best to include headers?
Use forward declarations (as in your example) whenever possible. This reduces compile times, but more importantly minimizes header and library dependencies for code that doesn't need to know and doesn't care for implementation details. In general, no code other than the actual implementation should care about implementation details.
Here is Google's rationale on this: Header File Dependencies
Class Forward Declaration C++
Forward declaration is not enough, you have to make some change on the StockObserver::StockGrabber(StockObserver so) member functions' signature, because if you pass the argument by value you need the definition not only the declaration of the parameters' class. If you pass by reference, then the declaration is enough for declaring the function, but that declaration is not surely enough for implement that function, so may be you will have to define the function outside of the class after StockObserver class defintion. Look at the code below, an it will be more understandable.
class Subject{ /* ... */ };
class Observer{ /* ... */ };
class StockObserver;
class StockGrabber: public Subject {
//...
//the constructor involves a StockObserver object
StockGrabber(StockObserver& so); // class StockObserver is declared before StockGrabber::StockGrabber(StockObserver&).
};
class StockObserver: public Observer {
//...
StockObserver(StockGrabber sg) { /* ... */ };
};
StockGrabber::StockGrabber(StockObserver& so){ /* ... */ } // class StockObserver is defined before StockGrabber::StockGrabber(StockObserver&).
C++ class forward declaration
In order for new T
to compile, T
must be a complete type. In your case, when you say new tile_tree_apple
inside the definition of tile_tree::tick
, tile_tree_apple
is incomplete (it has been forward declared, but its definition is later in your file). Try moving the inline definitions of your functions to a separate source file, or at least move them after the class definitions.
Something like:
class A
{
void f1();
void f2();
};
class B
{
void f3();
void f4();
};
inline void A::f1() {...}
inline void A::f2() {...}
inline void B::f3() {...}
inline void B::f4() {...}
When you write your code this way, all references to A and B in these methods are guaranteed to refer to complete types, since there are no more forward references!
What is forward declaration in c++? [duplicate]
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;
};
C++ Forward declare using directive
You can't declare a using
alias without defining it. You can declare your class template without defining it, however, and use a duplicate using
alias:
namespace fancy {
template <typename> class Foo;
class Bar;
using FooBar = Foo<Bar>;
}
Related Topics
Most Efficient Way to Find the Greatest of Three Ints
How to Convert String to Ip Address and Vice Versa
What Are the Basic Rules and Idioms For Operator Overloading
What Is the Most Effective Way For Float and Double Comparison
How to Test Whether Stringstream Operator≫≫ Has Parsed a Bad Type and Skip It
Passing Capturing Lambda as Function Pointer
Balanced Array Index While Summing an Array from Left and Right
Checking If All Elements of a Vector Are Equal in C++
Can a Local Variable'S Memory Be Accessed Outside Its Scope
When and Why Will a Compiler Initialise Memory to 0Xcd, 0Xdd, etc. on Malloc/Free/New/Delete
Capture Characters from Standard Input Without Waiting For Enter to Be Pressed