正如Luc Touraille已经很好地解释了在哪里使用和不使用类的前向声明。

我再补充一下为什么我们需要用它。

我们应该尽可能使用Forward声明，以避免不必要的依赖注入。

由于#include头文件被添加到多个文件中，因此，如果我们将一个头文件添加到另一个头文件中，它将在源代码的各个部分添加不必要的依赖注入，这可以通过尽可能将#include头文件添加到.cpp文件中来避免，而不是添加到另一个头文件中，并在头文件.h文件中尽可能使用类前向声明来避免。

到目前为止，没有一个答案描述了何时可以使用类模板的前向声明。所以，开始吧。

类模板可以被声明为:

template <typename> struct X;

按照公认答案的结构，

以下是你能做的和不能做的。

使用不完整类型可以做什么:

Declare a member to be a pointer or a reference to the incomplete type in another class template: template <typename T> class Foo { X<T>* ptr; X<T>& ref; }; Declare a member to be a pointer or a reference to one of its incomplete instantiations: class Foo { X<int>* ptr; X<int>& ref; }; Declare function templates or member function templates which accept/return incomplete types: template <typename T> void f1(X<T>); template <typename T> X<T> f2(); Declare functions or member functions which accept/return one of its incomplete instantiations: void f1(X<int>); X<int> f2(); Define function templates or member function templates which accept/return pointers/references to the incomplete type (but without using its members): template <typename T> void f3(X<T>*, X<T>&) {} template <typename T> X<T>& f4(X<T>& in) { return in; } template <typename T> X<T>* f5(X<T>* in) { return in; } Define functions or methods which accept/return pointers/references to one of its incomplete instantiations (but without using its members): void f3(X<int>*, X<int>&) {} X<int>& f4(X<int>& in) { return in; } X<int>* f5(X<int>* in) { return in; } Use it as a base class of another template class template <typename T> class Foo : X<T> {} // OK as long as X is defined before // Foo is instantiated. Foo<int> a1; // Compiler error. template <typename T> struct X {}; Foo<int> a2; // OK since X is now defined. Use it to declare a member of another class template: template <typename T> class Foo { X<T> m; // OK as long as X is defined before // Foo is instantiated. }; Foo<int> a1; // Compiler error. template <typename T> struct X {}; Foo<int> a2; // OK since X is now defined. Define function templates or methods using this type template <typename T> void f1(X<T> x) {} // OK if X is defined before calling f1 template <typename T> X<T> f2(){return X<T>(); } // OK if X is defined before calling f2 void test1() { f1(X<int>()); // Compiler error f2<int>(); // Compiler error } template <typename T> struct X {}; void test2() { f1(X<int>()); // OK since X is defined now f2<int>(); // OK since X is defined now }

不完整类型不能做的事情:

Use one of its instantiations as a base class class Foo : X<int> {} // compiler error! Use one of its instantiations to declare a member: class Foo { X<int> m; // compiler error! }; Define functions or methods using one of its instantiations void f1(X<int> x) {} // compiler error! X<int> f2() {return X<int>(); } // compiler error! Use the methods or fields of one of its instantiations, in fact trying to dereference a variable with incomplete type class Foo { X<int>* m; void method() { m->someMethod(); // compiler error! int i = m->someField; // compiler error! } }; Create explicit instantiations of the class template template struct X<int>;

我遵循的一般规则是除非必须，否则不包含任何头文件。所以除非我将一个类的对象存储为我的类的成员变量，否则我不会包括它，我只会使用前向声明。

在文件中，只使用指向类的指针或引用。指针/引用不能调用任何成员/成员函数。

//前向声明

我们可以声明类型为Foo*或Foo&的数据成员。

我们可以声明(但不能定义)带有Foo类型的参数和/或返回值的函数。

可以声明类型为Foo的静态数据成员。这是因为静态数据成员定义在类定义之外。

当您希望使用其他类型(类)作为类的成员时，通常需要在类头文件中使用正向声明。你不能在头文件中使用前向声明的类方法，因为c++还不知道那个类的定义。这就是你必须移动到. cppp文件的逻辑，但如果你使用的是模板函数，你应该将它们减少到只使用模板的部分，并将该函数移动到头文件中。

除了指向不完整类型的指针和引用外，还可以声明函数原型来指定不完整类型的参数和/或返回值。但是，不能定义具有不完整形参或返回类型的函数，除非它是指针或引用。

例子:

struct X;              // Forward declaration of X

void f1(X* px) {}      // Legal: can always use a pointer
void f2(X&  x) {}      // Legal: can always use a reference
X f3(int);             // Legal: return value in function prototype
void f4(X);            // Legal: parameter in function prototype
void f5(X) {}          // ILLEGAL: *definitions* require complete types