C++ .h #include class

最新推荐文章于 2023-03-06 14:05:15 发布
最新推荐文章于 2023-03-06 14:05:15 发布
阅读量999 收藏
点赞数
分类专栏： C++ 文章标签： c++
本文探讨了C++中两个头文件相互包含时的最佳实践，包括如何使用前向声明来避免无限循环包含的问题，并通过具体示例展示了正确的实现方式。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

C++头文件相互#include时最好是:

(1)在"CA.h"中 #include "CB.h".

(2)在"CB.h"中用类的前向声明: class CA;

(3)最好加上头文件卫士( #ifndef ***   #define ***  #endif)

示例如下:

(1)"CA.h":

#ifndef HEADER_CA

#define HEADER_CA

 

#include "CB.h"

 

class CA

{

         CB* pB;

         CB b;//正确,因为此处已经知道CB类的大小,且定义了CB,可以为b分配空间

};

 

#endif

---------------

(2)"CB.h":

#ifndef HEADER_CB

#define HEADER_CB

 

class CA;//这个必须要用,不能只用#include "CA.h",如果只是#include "CA.h"而没有class CA;则会报错.原因如附录[1].

class CB

{

         CA* pA;

         //CA a;//错误,因为此时还不知道CA的大小,无法分配空间

};

 

#endif

 

---------------

(3)"CA.cpp":

#include "CA.h"

----------------------------------

附录:

[1].h的头文件是不能单独被编译的,必须放在.cpp中.编译器在编译.cpp时会将该.cpp中的#include "*.h"中的头文件复制过来.例如在上面的"CA.cpp"中,编译器将#include展开后是:

(1)先将"CA.h"的内容复制过来:

#ifndef HEADER_CA

#define HEADER_CA

 

#include "CB.h"

 

class CA

{

         CB* pB;

         CB b;//正确,因为此处已经知道CB类的大小,且定义了CB,可以为b分配空间

};

 

#endif

(2)再处理(1),当遇到(1)中的 #include "CB.h" 时,将"CB.h"文件的内容再复制过来:

#ifndef HEADER_CA

#define HEADER_CA

 

//#include "CB.h" //此处被替换

         #ifndef HEADER_CB

         #define HEADER_CB

 

         class CA;//这个必须要用,不能只用#include "CA.h",如果只是#include "CA.h"而没有class    //CA;则会报错.原因如附录[1].

         class CB

         {

                   CA* pA;

                   //CA a;//错误,因为此时还不知道CA的大小,无法分配空间

         };

 

         #endif

 

 

class CA

{

         CB* pB;

         CB b;//正确,因为此处已经知道CB类的大小,且定义了CB,可以为b分配空间

};

 

#endif

-----------------------------

从上面代码可知,用class CA;是正确的.

如果把class CA;换成#include "CA.h",则变为:

#ifndef HEADER_CA

#define HEADER_CA

 

//#include "CB.h" //此处被替换

         #ifndef HEADER_CB

         #define HEADER_CB

 

         #include "CA.h"//如果不用class CA;

         class CB

         {

                   CA* pA;

                   //CA a;//错误,因为此时还不知道CA的大小,无法分配空间

         };

 

         #endif

 

 

class CA

{

         CB* pB;

         CB b;//正确,因为此处已经知道CB类的大小,且定义了CB,可以为b分配空间

};

 

#endif

-----------------------------

编译器再处理时,又发现了#include "CA.h",则再把"CA.h"文件的内容复制过来:

#ifndef HEADER_CA        

#define HEADER_CA        //-------[1]

 

//#include "CB.h" //此处被替换

         #ifndef HEADER_CB

         #define HEADER_CB

 

                   //#include "CA.h"//如果不用class CA;

                   #ifndef HEADER_CA                            //-------[10]

                   #define HEADER_CA

 

                   #include "CB.h"

 

                   class CA

                   {

                            CB* pB;

                            CB b;//正确,因为此处已经知道CB类的大小,且定义了CB,可以为b分配空间

                   };

 

                   #endif                                                      //-------[100]

 

         class CB

         {

                   CA* pA;                                                  //-------[200]

                   //CA a;//错误,因为此时还不知道CA的大小,无法分配空间

         };

 

         #endif

 

 

class CA

{

         CB* pB;

         CB b;//正确,因为此处已经知道CB类的大小,且定义了CB,可以为b分配空间

};

 

#endif

编译器再分析时,发现[10]处的HEADER_CA 已经被定义(在[1]处),所以不再定义[10]~[100]之间的代码(即绿色的部分).然后在[200]处定义CA  a时发现并没有声明CA(没有class CA),所以产生错误.

 

总之,如果二个头文件相互引用时,最好不是二个都用#include.

当然如果二个头文件中并没有用到另一个头文件中的类时,二个头文件是可以相互#include的(可以像前面那样自己把#include展开分析):

(1)"CA.h":

#ifndef HEADER_CA

#define HEADER_CA

 

#include "CB.h"

 

class CA

{

         CB* pB;

};

 

#endif

---------------

(2)"CB.h":

#ifndef HEADER_CB

#define HEADER_CB

 

class CA;

#include "CA.h"

 

class CB

{

         CA* pA;

};

 

#endif

.cpp文件单独#icnlude “CA.h” 或者#icnlude “CB.h”都是正确的。

其中#icnlude “CB.h”为：

#ifndef HEADER_CB

#define HEADER_CB

class CA;

#include "CA.h"

class CB

{

CA* pA;

};

#endif

把第4行的#include "CA.h"再替换，得：

#ifndef HEADER_CB

#define HEADER_CB

class CA;

  #ifndef HEADER_CA

  #define HEADER_CA

  #include "CB.h"

  class CA

  {

  CB* pB;

  };

  #endif

 

class CB

{

CA* pA;

};

#endif

将第6行的#include "CB.h"替换，得：

 

#ifndef HEADER_CB

#define HEADER_CB

class CA;

 

  #ifndef HEADER_CA

  #define HEADER_CA

 

    #ifndef HEADER_CB

    #define HEADER_CB

    class CA;

    #include "CA.h"

    class CB

    {

    CA* pA;

    };

    #endif

  class CA

  {

  CB* pB;

  };

  #endif

class CB

{

CA* pA;

};

其中，绿色部分是无用，会被忽略。

json解析教程（3）C++ json解析实战之读写json文件
二进制君
02-27 812
#include "json/json.h" #include <fstream> #include <iostream> class JsonParse { public: static bool ParseJsonFromFile(const std::string &filename, Json::Value *root) { std::ifstream ifs; ifs.open(filename); Jso
C++中的头文件#include<iostream>和标准命名空间 using namespace std
肆拾伍的博客
12-06 9591
#include <iostream> using namespace std 在最开始接触C++的时候，我始终不明白为什么在所有程序开头都要加上这两句，随着后续对类的理解，以及其他语言比如python的学习，慢慢的就能够理解了。 这两行代码旨在简化程序，一般来说编译器都能够识别这两句，否则说明编译器不遵循C++98标准，实际上如果不加这两句代码也是可以的，但是需要对后续的代码进行...
#include和直接写class加类名的区别
JXES智能生态系统
04-09 1054
include和直接写class加类名的区别 假设B的定义是在B.h中，而存在下面这个文件： // A.h -------------------------------------------- class A { private: 　　B * impl_; }; -------------------------------------------- // A.cpp -----...
c++ 头文件包含问题-include&class
瞎几波写
05-30 4675
在一些大的工程中，可能会包含几十个基础类，免不了之间会互相引用(不满足继承关系，而是组合关系)。也就是需要互相声明。好了，这时候会带来一些混乱。如果处理得不好，会搞得一团糟，根据我的经验，简单谈谈自已的处理办法： 编码时，我们一般会尽量避免include头文件，而是采用声明class XXX。 但有时候还是必须用Include头文件，那么，两者的划分在于什么呢？ 应该是很明确的，但书上
#include,#import,@class的区别 .....
lookyou111的专栏
04-22 666
#include         #include             #include "xx.h":用于对用户自定义的文件的引用，编译器首先会去用户目录下查找，然后去安装目录，最后去系统目录查找。          注：使用include要注意重复引用的问题：          class A，class B都引用了class C，class D若引用class A与clas
C++——class与#include
windxgz的博客
08-05 668
在写工程代码的时候经常会看到使用class进行类的预声明，而不是使用#include的将文件导入。 好处是减少编译的时间，因为如果使用#include的方式将文件导入的话，只要其中某一个类进行了更改，那么相关的所有用到这个类的类全部要重新编译，但如果使用class的话就不用全部重新编译。 但是使用class的话，一般是指针，引用和返回值的时候使用，如果生成的是对象的话就必须要使用#include来进行导入，因为使用指针的时候声明的时候是不开辟空间的，所以可以使用class。 就算在头文件中使用class，在
类的前向声明，class和include的区别
wuyu1125的专栏
09-15 1963
前向声明的定义：有些时候我们可以声明一些类但是并不去定义它，当然这个类的作用也很有限了。 比如class foo; 声明一个foo类，这个声明，有时候也叫做前向声明(forward declaration)，在声明完这个foo类之后，定义完这个foo类之前的时期，foo类是一个不完全的类型(incomplete type)，也就是说foo类是一个类型，但是这个类型的一些性质(比如包含哪些成员，
简单谈谈c/c++中#import、#include和@class的区别
01-21
1. import会包含这个类的所有信息，包括实体变量和方法（.h文件中），而@class只是告诉编译器，其后面声明的名称是类的名称，至于这些类是如何定义的，后面会再告诉你。 2. 在头文件中， 一般只需要知道被引用的类的...
关于C++ .h文件和.cpp文件的知识梳理
qq_41582834的博客
02-07 3194
C++ 关于.h文件和.cpp文件的知识梳理（1）1. C++程序的编译过程2. #pragma once 有什么作用3. 在头文件中定义static变量和const常量4.正确声明和定义变量的方法--extern 1. C++程序的编译过程 C++程序的编译过程可以分为四个步骤，分别为预处理, 编译，汇编，链接。他们的工作内容分别为： 预处理：展开头文件，去除源代码中的注释等。 编译： 将预处理后的程序转换成汇编代码。 汇编： 将汇编代码进一步转换成二进制机器码。 链接：将多个目标文件及其所需的库文件
C++实现飞机大战
Mark_GXc的博客
01-05 5258
C++小游戏飞机大战 废话不多说，直接看代码吧（转载） #include<iostream> #include<windows.h> #include<conio.h> #include<time.h> #include<string> using namespace std; /*=============== all the structures ===============*/ typedef struct Frame { COO
#import ,#include,@class 的区别
Xiumudiao的专栏
12-13 479
#include         区分 #include 与#include "x.h"的作用         #include :它用于对系统自带的头文件的引用，编译器会在系统文件目录下去查找该文件.          #include "x.h":用户自定义的文件用双引号引用，编译器首先会在用户目录下查找，然后到安装目录中查找，最后在系统文件中查找。  
class和#include 的区别
发现问题，解决问题.
01-13 930
用#include 1.可以使用#include包含空间内类的API。 2.会是两个文件关联起来，一个文件的改变，会在编译的时候让多个文件需要重新编译，加大了编译的时间。 用class 1.不能知道文件内类的信息。 2.不会加大编译时间。 3.一般用在仅需要使用这个类的指针、引用、函数返回值的场合。
C++ 类(class)的具体实现
ZhangzrJerry的博客
12-26 1210
类和头文件在实际应用中有许多特殊之处，在本篇中我们让一起探讨类和头文件的应用方式吧，走入一个新的代码世界
#include,#import与@class
Robin Hu的专栏
06-28 509
一、基本意义 #include         #include      :用于对系统文件的引用，编译器会在系统文件目录下去查找该文件。         #include "xx.h":用于对用户自定义的文件的引用，编译器首先会去用户目录下查找，然后去安装目录，最后去系统目录查找。        注：使用include要注意重复引用的问题：        class
c++多文件(.c和.h)中类的调用
qq_38830492的博客
03-06 1817
楼主原来是写电控程序的，最近在学习c++，发现c和c++的开发方式存在一些异同，在此做一个小结。
C++头文件包含中Class和Include的区别
c_I_always的博客
10-22 3483
如图所示： 在main函数上我直接class了一个类，然而此时，我这个类并不存在，但是却编译成功 同理： 当我Include这个不存在的类的时候却编译报错 原因： class  类名只是声明存在这么一个类，但是通过这个声明无法得到任何关于此类的具体信息。这样你可以在其他使用到的地方声明一个该类型的指针。  include头文件则是将整个该头文件与使用到的地方关联起来。  ...
include和class+类名的区别
05-06 492
#include "xx.h" 在编译的时候把xx.h文件直接展开，所以里面的接口都能用，可以申明对象。 但是classxx;这种方式就不会，你只能使用它的指针或者引用，你不能创建对象。 http://www.cnblogs.com/ORC-Lee/p/4848220.html 假设B的定义是在B.h中，而存在下面这个文件： // A.h ----------------
//A.h #pragma once class One{}; //B.h #include A.h //C.h #include "B.h" #include "A.h" 为什么显示One重定义
最新发布
03-18
<think>好的，我现在需要解决用户关于头文件重定义的问题。用户提供的例子中，有三个头文件：A.h、B.h和C.h。当编译C.h时，出现One类重定义的错误。我需要找出为什么会这样，并解释清楚原因。 首先，我应该回忆一下C++中的头文件包含机制和防止重复包含的方法。用户提到在A.h中使用了`#pragma once`，这是常见的防止头文件重复包含的方法。接下来，B.h包含了A.h，而C.h又包含了B.h和A.h。看起来可能是在C.h中直接和间接地包含了A.h两次，导致重复定义。 让我一步步分析。当C.h包含B.h时，B.h又包含A.h。这时，A.h被第一次包含，`#pragma once`会生效，防止后续的重复包含。但是，C.h接下来又直接包含了A.h，这里可能会出现问题。因为如果编译器在处理第二个包含时，`#pragma once`已经标记过A.h，所以第二次包含应该被跳过。这样的话，理论上不应该出现重定义错误。 不过，用户遇到了重定义的问题，说明可能还有其他因素。可能的错误原因包括：没有正确使用头文件保护符，或者头文件保护符在某些情况下失效。比如，如果A.h没有正确使用`#pragma once`，或者编译器不支持该指令，或者存在不同的文件路径导致编译器认为这是不同的头文件。 另外，可能需要检查文件的实际内容。比如，A.h中是否真的只有一个类定义，是否有其他内容导致重复定义。或者是否存在多个同名的头文件在不同的目录下，导致编译器认为它们是不同的文件，从而重复包含。 再仔细看一下用户提供的代码： //A.h #pragma once class One{}; //B.h #include "A.h" //C.h #include "B.h" #include "A.h" 在这种情况下，当C.h包含B.h时，B.h包含A.h，此时A.h的`#pragma once`生效，A.h的内容被包含一次。接着C.h又直接包含A.h，但由于`#pragma once`的存在，这次包含会被跳过。因此，One类应该只被定义一次，不应该出现重定义错误。 那为什么用户会遇到重定义的问题呢？可能的原因有几个： 1. 编译器不支持`#pragma once`。虽然现代编译器大多支持，但某些旧版本或特殊环境可能不支持，此时需要使用传统的#ifndef防卫式头文件保护。 2. 文件路径问题。如果A.h在B.h和C.h中被包含的路径不同，比如一个是相对路径，另一个是绝对路径，或者有符号链接，导致编译器认为它们是不同的文件，从而绕过了`#pragma once`的保护。 3. 代码中存在其他错误，比如在头文件中除了类定义之外还有其他可能导致重复定义的代码，比如全局变量的定义，而不仅仅是声明。 用户提供的例子中，A.h只有类定义，没有问题。但如果实际代码中有其他内容，比如内联函数的定义或者模板的具体化，可能会导致问题。 假设用户正确使用了`#pragma once`，并且编译器支持，那么问题可能出在文件路径的不同。例如，如果B.h包含的是"A.h"（使用引号），而C.h包含的是不同的路径下的A.h，或者由于项目配置导致包含路径不同，使得编译器认为两次包含的是不同的文件，从而触发重定义。 另一个可能的情况是，用户没有正确保存文件，或者存在多个同名的A.h文件在不同的目录中，导致重复包含。 解决方案方面，建议用户检查以下几点： 1. 确保所有头文件都正确使用`#pragma once`或者传统的#ifndef防卫式宏。 2. 检查包含路径是否正确，确保同一个头文件不会被不同的路径包含。 3. 避免在头文件中定义变量或非内联函数，只放置声明和类定义。 如果用户使用的是传统的#ifndef方式，正确写法应该是： //A.h #ifndef A_H #define A_H class One{}; #endif 这样可以确保即使编译器不支持`#pragma once`，也能防止重复包含。 回到用户的问题，可能是在他们的实际代码中，A.h没有正确使用头文件保护符，或者存在路径问题。例如，如果B.h包含的是<A.h>而C.h包含的是"A.h"，并且编译器搜索路径中有不同的A.h，这可能导致重复包含。或者，用户可能在A.h中不小心重复定义了One类。 总结，用户的问题可能是因为在C.h中两次包含A.h，但由于路径问题或其他原因，`#pragma once`没有生效，导致One类被重复定义。解决方法包括检查头文件保护符的正确性，统一包含路径，确保每个头文件只被包含一次。</think>$$ \text{头文件重复包含问题解析} $$ 在C++项目中出现`One`类重定义错误，本质是头文件包含链导致类定义被多次展开。以下是具体分析及解决方案： --- ### **问题根源分析** 观察头文件包含关系： ```cpp // C.h #include "B.h" // 展开B.h → 展开A.h（第一次定义One） #include "A.h" // 尝试再次展开A.h（触发重定义） ``` 虽然`A.h`使用了`#pragma once`，但以下情况会导致防卫失效： 1. **不同包含路径**：若`B.h`和`C.h`包含`A.h`的路径不同（如一个用`<>`一个用`""`且搜索路径不同） 2. **文件系统符号链接**：不同路径指向同一个物理文件但被编译器识别为不同文件 3. **编译器兼容性问题**：极少数旧编译器对`#pragma once`支持不完善 --- ### **标准解决方案** #### 步骤1：统一使用防卫式头文件风格 ```cpp // A.h改进方案 #ifndef A_H_INCLUDED // 唯一标识宏 #define A_H_INCLUDED class One {}; #endif ``` - **优势**：兼容所有C++标准（C++98起支持） - **原理**：宏定义守卫确保仅首次包含时展开内容 #### 步骤2：规范包含路径规则 - 统一使用相对路径或绝对路径 - 避免混合使用`#include <A.h>`和`#include "A.h"`包含同一文件 #### 步骤3：验证文件系统一致性 ```bash # Linux/Mac查看真实路径 realpath A.h # Windows查看文件属性 ``` --- ### **实例验证** 修改后的正确结构： ```cpp // A.h #ifndef A_H_INCLUDED #define A_H_INCLUDED class One {}; #endif // B.h #include "A.h" // 展开A.h → 定义A_H_INCLUDED宏 // C.h #include "B.h" // A_H_INCLUDED已定义，不再展开A.h #include "A.h" // 因宏守卫跳过内容 ``` 此时编译过程： 1. C.h包含B.h → B.h包含A.h → `A_H_INCLUDED`宏被定义 → One类定义 2. C.h再包含A.h → 检测到`A_H_INCLUDED`已定义 → 跳过内容 --- ### **扩展预防措施** 1. **编译诊断**： ```bash g++ -E -dD C.cpp > preprocessed.txt # 查看预处理结果 ``` 检查预处理文件中`One`类的出现次数 2. **项目配置优化**： ```cmake target_include_directories(MyTarget PUBLIC include) # 统一包含目录 ``` 3. **静态分析工具**： ```bash cppcheck --enable=all --project=compile_commands.json ``` --- **最终结论**：问题源于`A.h`被不同路径多次包含导致防卫失效。通过`#ifndef`+宏守卫可彻底解决问题，建议结合编译预处理检查确保防卫生效。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值