C++ Curiously Recurring Template Pattern "uses undefined struct" compile error - c++

Question

I have two classes using the Curiously Reoccurring Template Pattern with a parent class.
When I compile on VS2013 I get two errors, one for each subclass, stating:
'Parent<Child1>::_child' uses undefined struct 'Child1'
'Parent<Child2>::_child' uses undefined struct 'Child2'
Am I including the files incorrectly, or do I need to make some sort of forward declaration?
Child1.h
#include "Parent.h"
struct Child1 : public Parent<Child1>
{
void init()
{
sharedCode();
}
};
Child2.h
#include "Parent.h"
struct Child2 : public Parent<Child2>
{
void init()
{
sharedCode();
}
};
Parent.h
template<class CHILD>
struct Parent
{
void sharedCode()
{
}
CHILD _child;
};
main.cpp
#include "Child1.h"
#include "Child2.h"
int main()
{
Child1 c1;
Child2 c2;
}

Answer 1

When using the recurring template pattern, the child is an incomplete type in the scope of the parent.
template<class CHILD>
struct Parent
{
CHILD _child; // <- there, incomplete
};
You cannot instantiate an incomplete type as its definition is not there yet.
So... why is that?
A type become complete when the compiler encounter the closing bracket:
struct Hello {
// Technically not complete yet
};
// Complete here, we encountered the closing bracket.
Also, parent classes are required to be complete type themselves:
struct Incomplete;
struct NiceTry : Incomplete {}; // ERROR! `Incomplete` is an incomplete type.
So we have two rules here: the parent of a class must be complete, and a type is not complete until the closing bracket. Inside the parent of a CRTP, we fail both condition: The parent is evaluated before the class scope (they are also positionned before the class scope in the code) and since the parent of a class must be complete, it must be complete before the child class is. You cannot have mutually complete types in class scope, no matter how hard you try:
struct class2;
struct class1 {
// Class 2 is incomplete here
};
struct class2 {
// class1 complete
};
You cannot have both complete at the same time in both scopes.
The same thing happens with CRTP, there is no exceptions there.
Also, your code is roughly equivalent to this:
struct class1 {
class2 instance;
};
struct class2 {
class1 instance;
};
If you try to compute the size of the types, you run into an infinite recursion. You cannot have a type that contain itself.
To fix your problem, don't try to contain the child. Instead, since you know 100% which class is the child, simply cast this:
template<typename Child>
struct parent {
void common_behavior() {
child().function1();
std::cout << child().member1 + child().member2;
}
private:
auto child() noexcept -> Child& { return *static_cast<Child*>(this); }
auto child() const noexcept -> Child const& { return *static_cast<Child const*>(this); }
};
And implement the child like that:
struct child1 : parent<child1> {
void function1() { std::cout << "This is child 1"; }
int member1, member2;
};
struct child2 : parent<child2> {
void function1() { std::cout << "This is child 2"; }
float member1, member2;
};
Live example