C++两个类的头文件相互包含_c++ 头文件相互包含-CSDN博客

`C++中头文件相互包含的几点问题`

一、类嵌套的疑问

C++头文件重复包含实在是一个令人头痛的问题，前一段时间在做一个简单的数据结构演示程序的时候，不只一次的遇到这种问题。假设我们有两个类A和B，分别定义在各自的有文件A.h和B.h中，但是在A中要用到B，B中也要用到A，但是这样的写法当然是错误的：class B;

class A{ public: B b;};

class B{ public: A a;};因为在A对象中要开辟一块属于B的空间，而B中又有A的空间，是一个逻辑错误，无法实现的。在这里我们只需要把其中的一个A类中的B类型成员改成指针形式就可以避免这个无限延伸的怪圈了。为什么要更改A而不是B？因为就算你在B中做了类似的动作，也仍然会编译错误，表面上这仅仅上一个先后顺序的问题。为什么会这样呢？因为C++编译器自上而下编译源文件的时候，对每一个数据的定义，总是需要知道定义的数据的类型的大小。在预先声明语句class B;之后，编译器已经知道B是一个类，但是其中的数据却是未知的，因此B类型的大小也不知道。这样就造成了编译失败，VC++6.0下会得到如下编译错误： error C2079: 'b' uses undefined class 'B'将A中的b更改为B指针类型之后，由于在特定的平台上，指针所占的空间是一定的（在Win32平台上是4字节），这样可以通过编译。

二、不同头文件中的类的嵌套

在实际编程中，不同的类一般是放在不同的相互独立的头文件中的，这样两个类在相互引用时又会有不一样的问题。重复编译是问题出现的根本原因。为了保证头文件仅被编译一次，在C++中常用的办法是使用条件编译命令。在头文件中我们常常会看到以下语句段（以VC++6.0自动生成的头文件为例）：

#if !defined(AFX_STACK_H__1F725F28_AF9E_4BEB_8560_67813900AE6B__INCLUDED_)#define AFX_STACK_H__1F725F28_AF9E_4BEB_8560_67813900AE6B__INCLUDED_ //很多语句……#endif

其中首句#if !defined也经常做#ifndef，作用相同。意思是如果没有定义过这个宏，那么就定义它，然后执行直到#endif的所有语句。如果下次在与要这段代码，由于已经定义了那个宏，因此重复的代码不会被再次执行。这实在是一个巧妙而高效的办法。在高版本的VC++上，还可以使用这个命令来代替以上的所有： #pragma once它的意思是，本文件内的代码只被使用一次。

但是不要以为使用了这种机制就全部搞定了，比如在以下的代码中：

//文件A.h中的代码#pragma once

#include "B.h"

class A{ public: B* b;};

//文件B.h中的代码#pragma once

#include "A.h"

class B{ public: A* a;};

这里两者都使用了指针成员，因此嵌套本身不会有什么问题，在主函数前面使用#include "A.h"之后，主要编译错误如下： error C2501: 'A' : missing storage-class or type specifiers仍然是类型不能找到的错误。其实这里仍然需要前置声明。分别添加前置声明之后，可以成功编译了。代码形式如下：

//文件A.h中的代码#pragma once

#include "B.h"

class B;

class A{ public: B* b;};

//文件B.h中的代码#pragma once

#include "A.h"

class B;

class B{ public: A* a;};

这样至少可以说明，头文件包含代替不了前置声明。有的时候只能依靠前置声明来解决问题。我们还要思考一下，有了前置声明的时候头文件包含还是必要的吗？我们尝试去掉A.h和B.h中的#include行，发现没有出现新的错误。那么究竟什么时候需要前置声明，什么时候需要头文件包含呢？

三、两点原则（非常重要）

头文件包含其实是一想很烦琐的工作，不但我们看着累，编译器编译的时候也很累，再加上头文件中常常出现的宏定义。感觉各种宏定义的展开是非常耗时间的，远不如自定义函数来得速度。我仅就不同头文件、源文件间的句则结构问题提出两点原则，仅供参考：

第一个原则应该是，如果可以不包含头文件，那就不要包含了。这时候前置声明可以解决问题。如果使用的仅仅是一个类的指针，没有使用这个类的具体对象（非指针），也没有访问到类的具体成员，那么前置声明就可以了。因为指针这一数据类型的大小是特定的，编译器可以获知。

第二个原则应该是，尽量在CPP文件中包含头文件，而非在头文件中。假设类A的一个成员是是一个指向类B的指针，在类A的头文件中使用了类B的前置声明并便宜成功，那么在A的实现中我们需要访问B的具体成员，因此需要包含头文件，那么我们应该在类A的实现部分（CPP文件）包含类B的头文件而非声明部分(H文件)。

如下在C++ primer（第五版）中的StrBlob中，chapter 12动态数组

如果把StrBlob中的成员函数begin()和end()写成

StrBlobPtr begin(){ return StrBlobPtr(*this);}StrBlobPtr end(){auto ret = StrBlobPtr(*this, data->size());return ret;}

但是将这两个成员函数的实现写在类中，由于会用到StrBlobPtr的成员函数，所以要引用“StrBlobPtr.h”的头文件，所以会出现相互引用。

StrBlob.h 如下：

#ifndef STRBLOB_H
#define STRBLOB_H

#include <vector>
#include <memory>
//#include "StrBlobPtr.h"  //当两个头文件相互包含的时候，编译是通不过的。

using namespace std;
class StrBlobPtr;

class StrBlob{
	friend ostream& operator<<(ostream &out, const StrBlob &blob);
	friend class StrBlobPtr;
public:
	typedef vector<string>::size_type size_type;
	StrBlob();
	StrBlob(initializer_list<string> il);
	size_type size(){ return data->size(); }
	void push_back(const string &str){ data->push_back(str); }
	void pop_back();
	const string &front()const ;
	const string &back()const ;
	ostream& operator<< (const ostream &out);
	StrBlobPtr begin();//因为，使用StrBlobStr,所以要包含StrBlobPtr头文件 。
	StrBlobPtr end();
private:
	shared_ptr<vector<string>> data;
	void check(size_type i, const string &msg)const;
};
ostream& operator<< (ostream &out,const StrBlob &blob);
#endif

我们通过

class StrBlobPtr;

来声明一下，而不引用 “StrBlobPtr.h”头文件，然后将成员函数begin()和end()在类的定义中声明，而不在其内部实现，放到StrBlobPtr.cpp中去实现。这样就不会出现相互引用了。

StrBlobPtr begin();//因为，使用StrBlobStr,所以要包含StrBlobPtr头文件 。
	StrBlobPtr end();

这两个函数，要使用StrBlobPtr来定义，我们可以将这两个函数放在StrBlob.cpp可实现就可以了。

StrBlob.cpp如下

#include "StrBlob.h"
#include "StrBlobPtr.h"
#include <iostream>
#include <string>

using namespace std;

StrBlob::StrBlob() :data(make_shared<vector<string>>()){}
StrBlob::StrBlob(initializer_list<string> il) : data(make_shared<vector<string>>(il)){}
void StrBlob::check(size_type i, const string &msg) const
{
	if (i >= data->size())
		throw out_of_range(msg);
}
void StrBlob::pop_back()
{
	check(0, "pop_back on empty StrBlob");
	data->pop_back();
}
const string &StrBlob::back() const
{
	check(0, "back on empty StrBlob");
	return data->back();
}

const string &StrBlob::front() const
{
	check(0, "front on empty StrBlob");
	return data->front();
}
ostream &operator<<(ostream &os, const StrBlob &strBlob)
{
	for (auto it = strBlob.data->begin(); it != strBlob.data->end(); it++){
		os << " " << *it;
	}
	return os;
}
StrBlobPtr StrBlob::begin()
{
	return StrBlobPtr(*this);
}

StrBlobPtr StrBlob::end()
{
	auto ret = StrBlobPtr(*this, data->size());
	return ret;
}

所以可以看出，引入头文件的两个原则还是很需要注意的啦：

第一个原则应该是，如果可以不包含头文件，那就不要包含了。这时候前置声明可以解决问题。如果使用的仅仅是一个类的指针，没有使用这个类的具体对象（非指针），也没有访问到类的具体成员，那么前置声明就可以了。因为指针这一数据类型的大小是特定的，编译器可以获知。

第二个原则应该是，尽量在CPP文件中包含头文件，而非在头文件中。假设类A的一个成员是是一个指向类B的指针，在类A的头文件中使用了类B的前置声明并便宜成功，那么在A的实现中我们需要访问B的具体成员，因此需要包含头文件，那么我们应该在类A的实现部分（CPP文件）包含类B的头文件而非声明部分(H文件)。