zoukankan      html  css  js  c++  java

  • [转]关于前置声明与C++中头文件相互包含的几点问题

    一个前置声明是指在程序员尚未给出完整定义之前对一个标示符(一个类型、一个变量或者一个函数)的声明。一个很简单的例子就是我们在函数A中使用了函数B，但是函数B的声明在函数A之后，这个时候，就需要对函数B进行前置声明，实际上就是在函数A之前提供一个函数B的原型(prototype)。这种现象其实在C语言编程中我们已经习以为常了，在C++中亦是如此，只不过在编写较大规模程序的时候，由于定义了较多的类，而这些类之间有可能是互相依赖的，换言之，类与类之间会互相引用，包括对成员函数的引用等等。

    比如需要在文档类调用视图类

    在doc头文件加前置声明
    class CTestView;
    如有必要在doc源文件加上testview.cpp（或者加在头文件也可），
    在testview也是如此，在头文件
    加前置声明
    class CTestDoc;
    源文件加testdoc.cpp（或者加在头文件也可）

    一、类嵌套的疑问

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

    C/C++代码
    [cpp] view plaincopy
     
    1. class B;     
    2.     
    3. class A     
    4. {     
    5.    public:     
    6.    B b;     
    7. };     
    8.     
    9. class B     
    10. {     
    11.    public:     
    12.    A a;     
    13. };     
    14.     
     

    因为在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
    它的意思是，本文件内的代码只被使用一次。

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

    C/C++代码
    [cpp] view plaincopy
     
    1. //文件A.h中的代码     
    2. #pragma once     
    3.     
    4. #include “B.h”     
    5.     
    6. class A     
    7. {     
    8.    public:     
    9.    B* b;     
    10. };     
    11.     
     
    C/C++代码
     
    [cpp] view plaincopy
     
    1. //文件B.h中的代码     
    2. #pragma once     
    3.     
    4. #include “A.h”     
    5.     
    6. class B     
    7. {     
    8.    public:     
    9.    A* a;     
    10. };     
    11.     


     

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

    C/C++代码
     
    C/C++代码
    [cpp] view plaincopy
     
    1. //文件A.h中的代码     
    2. #pragma once     
    3.     
    4. #include “B.h”     
    5.     
    6. class B;     
    7.     
    8. class A     
    9. {     
    10.    public:     
    11.    B* b;     
    12. };     
    13.     
    [cpp] view plaincopy
     
    1. //文件B.h中的代码     
    2. #pragma once     
    3.     
    4. #include “A.h”     
    5.     
    6. class B;     
    7.     
    8. class B     
    9. {     
    10.    public:     
    11.    A* a;     
    12. };     
    13.     
     
     

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

    三、两点原则

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

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

    第二个原则应该是，尽量在CPP文件中包含头文件，而非在头文件中。假设类A的一个成员是是一个指向类B的指针，在类A的头文件中使用了类B的前置声明并便宜成功，那么在A的实现中我们需要访问B的具体成员，因此需要包含头文件，那么我们应该在类A的实现部分（CPP文件）包含类B的头文件而非声明部分(H文件)。
  • 相关阅读:
    kakfa 安全机制
    配置管理
    消费者基本操作
    生产者基本操作
    笔记：类加载器
    主题管理
    记一次学习SpringCloud将zk作为注册中心的bug
    JVM新生代进入老年代、何时触发Full GC?
    JVM调优
    线程池
  • 原文地址：https://www.cnblogs.com/jasonleeee/p/3658948.html
Copyright © 2011-2022 走看看