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