C++里类的前置声明分析

首先，让我们来了解下C++里函数的情况，然后再类比到类的情况

一 C++下函数声明和定义

我们在用C++写代码时（假设源文件只有一个main.cpp），经常会按照以下步骤写：

1. 先对自定义的函数进行声明
2. 在main函数里调用第1步里声明好的函数
3. 编写函数的实际代码，这一步也叫函数的定义

简单例子如下，

#include <iostream>

using namespace std;

void func(void); // 函数声明

int main()
{
    
    func(); // 调用函数
    
    return 0;
}


void func(void) // 函数定义
{
    cout << "hello world\n";
}

可以看到C++允许函数的声明和定义分开，并且只要函数声明后就可以拿来使用，暂时不用去实现其具体定义，这其实也是可以对C/C++代码进行模块化管理的基础。

---

二 C++下类的前置声明

类似于函数的声明和定义，C++里类的声明和定义也是可以分开的。我们可以先声明而暂时不定义它，这种声明就称为类的前置声明，forward declaration。
class Screen;
这个前置声明在代码里引入了名字Screen，并指示Screen是一个类类型。

对于类类型Screen来说，在它声明之后定义之前是一个不完全类型，所谓不完全类型就是我们知道Screen是一个类类型，但是我们不知道它到底包含了哪些成员。

不完全类型只能在非常有限的情况下使用：

1. 只能定义指向这种不完全类型的指针或引用
2. 只能声明（但是不可以定义）以不完全类型作为参数或者返回类型的函数

以下代码是一个错误例子，在类Link_Screen里不能使用Screen去创建对象，只能去定义Screen类的指针或引用

class Screen; // Screen的前置声明

class Link_Screen
{
public:
    Screen window; // 错误，创建对象时该类必须已经定义过

    Link_Screen* prev;
    Link_Screen* next;
};

以下代码是正确例子，

class Screen; // Screen的前置声明

class Link_Screen
{
public:
    Screen* window; // 正确，只能创建Screen类的指针或引用

    Link_Screen* prev;
    Link_Screen* next;
};

---

三 类前置声明的好处

主要有2点：

1. 节约编译时间
   我们平时在写代码时会使用#include来包含其他头文件，然后调用这个头文件提供的一些类，如果该头文件里包含了很多其他没有被使用到的类，那么编译时会被一起编译，这样就会浪费一些不必要的时间，而使用前置声明，编译器就只编译我们需要用到的类，这样就会节约一点编译时间
2. 处理两个类相互依赖的问题
   假设有两个类，叫A和B，如果A里要用到B的成员函数，B里要用到A的成员函数，如果直接按照如下这样写，就会出错，

/******* A.h *******/
#ifndef _A_H_
#define _A_H_

#include <iostream>
#include "B.h"
class A
{
    B obj;
    void testA(void) {std::cout << "hello A\n";}
};

#endif // _A_H_
/*******************/

/******* B.h *******/
#ifndef _B_H_
#define _B_H_

#include <iostream>
#include "A.h"
class B
{
    A obj;
    void testB(void) {std::cout << "hello B\n";}
};

#endif // _B_H_
/*******************/

/***** main.h ******/
#include "A.h"

int main(void)
{
    A data;
    data.obj.testB();
    return 0;
}
/*******************/

这样写会导致无限循环包含，A.h包含B.h，B.h里包含A.h，A.h里又包含B.h，…，编译就会出错。

改用前置声明，就会避免这样的问题，不过写法有一定的限制，只能定义指针或引用，而且不能通过指针或引用来调用类的方法，因为此时该类类型是不完全类型，还不知道里面定义了哪些方法。

/******* A.h *******/
#ifndef _A_H_
#define _A_H_

#include <iostream>
class B;
class A
{
    B* ptr;
    void testA(void) {std::cout << "hello A\n";}
};

#endif // _A_H_
/*******************/

/******* B.h *******/
#ifndef _B_H_
#define _B_H_

#include <iostream>
class A;
class B
{
    A* ptr;
    void testB(void) {std::cout << "hello B\n";}
};

#endif // _B_H_
/*******************/

/***** main.h ******/
#include "A.h"
#include "B.h"

int main(void)
{
    A dataA;
    dataA.ptr = new B();
    dataA.ptr->testB();
    
    B dataB;
    dataB.ptr = new A();
    dataB.ptr->testA();
    
    return 0;
}
/*******************/

上述写法是A中包含B的指针，B中包含A的指针，还可以写成A中包含B的对象，B中包含A的指针，如下，

/******* A.h *******/
#ifndef _A_H_
#define _A_H_

#include <iostream>
#include "B.h"
class A
{
    B obj;
    void testA(void) {std::cout << "hello A\n";}
};

#endif // _A_H_
/*******************/

/******* B.h *******/
#ifndef _B_H_
#define _B_H_

#include <iostream>
class A;
class B
{
    A* obj;
    void testB(void) {std::cout << "hello B\n";}
};

#endif // _B_H_
/*******************/

/***** main.h ******/
#include "A.h"
#include "B.h"

int main(void)
{
    A dataA;
    dataA.obj.testB();
    
    B dataB;
    dataB.obj = new A();
    dataB.obj->testA();
    return 0;
}
/*******************/

---

四 类前置声明的坏处

这里直接引用Google C++ Style里的关于前置声明的缺点说明：

(1) 前置声明隐藏了依赖关系，头文件改动时，用户的代码会跳过必要的重新编译过程。
(2) 前置声明可能会被库的后续更改所破坏。前置声明函数或模板有时会妨碍头文件开发者变动其 API.例如扩大形参类型，加个自带默认参数的模板形参等等。
(3) 前置声明来自命名空间std:: 的 symbol 时，其行为未定义。
(4) 很难判断什么时候该用前置声明，什么时候该用 #include 。极端情况下，用前置声明代替 includes 甚至都会暗暗地改变代码的含义.

---

五 总结

类的前置声明既有优点又有缺点，我们使用时可以根据具体情况去选择。这里再引用下Google C++ Style里的关于前置声明的使用说明，

(1) 尽量避免前置声明那些定义在其他项目中的实体.
(2) 函数：总是使用#include.
(3) 类模板：优先使用#include.

但是如果出现类的互相依赖，使用前置声明还是一个比较好的解决办法，或者通过重新对类进行设计，来避免互相依赖。

如果有写的不对的地方，希望能留言指正，谢谢阅读。