我正在寻找允许在另一个类的头文件中进行类的前向声明的定义：
我是否允许为基类，作为成员持有的类，通过引用传递给成员函数的类等执行此操作？
让自己处于编译器的位置：当你转发声明一个类型时，所有编译器都知道这个类型存在;它对它的大小，成员或方法一无所知。这就是为什么它被称为不完整类型。因此，您不能使用该类型来声明成员或基类，因为编译器需要知道该类型的布局。
假设以下前瞻性声明。
class X;
这是你能做什么，不能做的。
你可以用不完整的类型做什么：
class Foo {
X *pt;
X &pt;
};
void f1(X);
X f2();
void f3(X*, X&) {}
X& f4() {}
X* f5() {}
你不能用不完整的类型做什么：
class Foo : X {} // compiler error!
class Foo {
X m; // compiler error!
};
void f1(X x) {} // compiler error!
X f2() {} // compiler error!
class Foo {
X *m;
void method()
{
m->someMethod(); // compiler error!
int i = m->someField; // compiler error!
}
};
对于模板，没有绝对规则：是否可以使用不完整类型作为模板参数取决于模板中使用类型的方式。
例如，std::vector<T>要求其参数为完整类型，而boost::container::vector<T>则不需要。有时，只有在使用某些成员函数时才需要完整类型;例如，this is the case for std::unique_ptr<T>。
记录良好的模板应在其文档中指出其参数的所有要求，包括它们是否需要完整类型。
当您希望将其他类型（类）用作类的成员时，通常需要在类头文件中使用前向声明。您不能在头文件中使用前向声明的类方法，因为C ++当时还不知道该类的定义。这是你必须进入.cpp文件的逻辑，但如果你正在使用模板函数，你应该将它们减少到只使用模板的部分并将该函数移动到标题中。
认为前向声明将使您的代码编译（obj已创建）。但是，除非找到定义，否则链接（exe创建）将不会成功。
我只想添加一个重要的事情，你可以用Luc Touraille的答案中没有提到的转发课程。
你可以用不完整的类型做什么：
定义接受/返回指向不完整类型的指针/引用的函数或方法，并将指针/引用转发给另一个函数。
void f6(X*) {}
void f7(X&) {}
void f8(X* x_ptr, X& x_ref) { f6(x_ptr); f7(x_ref); }
模块可以将前向声明的类的对象传递给另一个模块。
主要规则是您只能转发声明其内存布局（以及成员函数和数据成员）不需要在您转发声明它的文件中知道的类。
这将排除基类和除引用和指针使用的类之外的任何东西。
除了指向不完整类型的指针和引用之外，您还可以声明指定参数和/或返回不完整类型值的函数原型。但是，除非是指针或引用，否则无法定义具有不完整的参数或返回类型的函数。
例子：
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
到目前为止，没有一个答案描述何时可以使用类模板的前向声明。所以，在这里。
可以将类模板转发声明为：
template <typename> struct X;
遵循accepted answer的结构，
这是你能做什么，不能做的。
你可以用不完整的类型做什么：
template <typename T>
class Foo {
X<T>* ptr;
X<T>& ref;
};
class Foo {
X<int>* ptr;
X<int>& ref;
};
template <typename T>
void f1(X<T>);
template <typename T>
X<T> f2();
void f1(X<int>);
X<int> f2();
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; }
void f3(X<int>*, X<int>&) {}
X<int>& f4(X<int>& in) { return in; }
X<int>* f5(X<int>* in) { return in; }
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.
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.
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
}
你不能用不完整的类型做什么：
class Foo : X<int> {} // compiler error!
class Foo {
X<int> m; // compiler error!
};
void f1(X<int> x) {} // compiler error!
X<int> f2() {return X<int>(); } // compiler error!
class Foo {
X<int>* m;
void method()
{
m->someMethod(); // compiler error!
int i = m->someField; // compiler error!
}
};
template struct X<int>;
在只使用指针或引用类的文件中。如果指针/引用，则不应调用任何成员/成员函数。
与class Foo; //前方声明
我们可以声明Foo *或Foo＆类型的数据成员。
我们可以使用Foo类型的参数和/或返回值声明（但不定义）函数。
我们可以声明Foo类型的静态数据成员。这是因为静态数据成员是在类定义之外定义的。
我写这个作为一个单独的答案，而不仅仅是一个评论，因为我不同意Luc Touraille的答案，不是基于合法性，而是强大的软件和误解的危险。
具体来说，我对您希望界面用户必须知道的隐含合同存在问题。
如果您要返回或接受引用类型，那么您只是说它们可以通过指针或引用，而这些指针或引用只能通过前向声明来知道。
当你返回一个不完整类型的X f2();然后你说你的调用者必须具有X的完整类型规范。他们需要它来在呼叫站点创建LHS或临时对象。
同样，如果接受不完整类型，则调用者必须构造作为参数的对象。即使该对象作为函数中的另一个不完整类型返回，调用站点也需要完整声明。即：
class X; // forward for two legal declarations
X returnsX();
void XAcceptor(X);
XAcepptor( returnsX() ); // X declaration needs to be known here
我认为有一个重要的原则，标题应该提供足够的信息来使用它，而不需要其他标头的依赖。这意味着当您使用它声明的任何函数时，标题应该能够包含在编译单元中而不会导致编译器错误。
除了
只要您不需要定义（思考指针和引用），您就可以使用前向声明。这就是为什么大多数情况下你会在标题中看到它们，而实现文件通常会拉出适当定义的标题。
我遵循的一般规则是不包括任何头文件，除非我必须。因此，除非我将类的对象存储为我的类的成员变量，否则我将不会包含它，我将只使用前向声明。