C ++：在main.cpp中声明结构的任何可能性，但在头文件中具有类的模板

Question

As a beginner in C++ with templates I have a question, sorry if it's ridiculous.

With having a template in header file like this one:

template <class T> class MyClass

is it possible to define a structure in the main.cpp like this:

struct CC;

struct CC
{

     MyClass (CC) p;
     CC() : p(0){}
}; 

Or :

struct Foo {

    MyClass<struct Foo> bar;
    MyClass<std::string> text;
};

I am very lost at this. Sorry.

Answer 1

First, whether the template is in a header file or not, does not matter. The compiler proper only sees the code after preprocessing, and at that point there are no files. Just text.

Let's consider a variation of your first example:

template< class T >
class MyClass
{
    int x;
};

struct CC
{

     MyClass<CC> m;
     CC() {}
}; 

auto main() -> int {}

This compiles fine because the MyClass template doesn't actually use CC for anything, and so no knowledge of it other than that it's a type, is needed.

But let's say that its size is used. That requires a complete type . Or put another way, a complete type is a type whose size is known.

template< class T >
class MyClass
{
    char x[sizeof( T )];
};

struct CC
{

     MyClass<CC> m;
     CC() {}
}; 

auto main() -> int {}

This shall not compile, because at the point where MyClass<CC> is used, the size of CC is not yet known. Additional data members, or eg a virtual function, could be defined later in the class definition. That would increase the size.

---

As a near counter-example, consider this third variant:

template< class T >
class MyClass
{
public:
    void foo()
    {
        char x[sizeof( T )];
    }
};

struct CC
{

     MyClass<CC> m;
     void use_foo() { m.foo(); }
     CC() {}
}; 

auto main() -> int {}

This compiles fine, but why? Apparently also here the template requires a complete CC type?

But no, the compiler treats member function definitions in a class as if they'd been declared inline and defined outside of the class, like this:

template< class T >
class MyClass
{
public:
    inline void foo();
};

template< class T >
void MyClass<T>::foo()
{
    char x[sizeof( T )];
}

struct CC
{

     MyClass<CC> m;
     inline void use_foo();
     CC() {}
}; 

void CC::use_foo() { m.foo(); }

auto main() -> int {}

And from this you can see that the MyClass template itself does not depend on knowledge of the size of CC .