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

最新推荐文章于 2023-05-23 20:20:57 发布
最新推荐文章于 2023-05-23 20:20:57 发布
阅读量1w 收藏 39
点赞数 18
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/whahu1989/article/details/83627658
版权

首先，让我们来了解下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.

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

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

爱就是恒久忍耐
关注
专栏目录
关于C++的前向声明问题
cay22的专栏
01-07 2348
 一. 不好的习惯 // A.h class A { public: A(); }; // A.cpp #include "A.h" A::A(){} ///////////////////////////////////// // B.h #include "A.h" // 这里包含头文件不好 // 因为 class B声明中只是用了A* class B {
c++之类的前置声明分析
黄土塬
11-20 1758
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 1、 概念 （1）、类a声明中需要类b的类型，类b的声明中需要类a的类型 （2）、a类中的.h文件中包含b.h,类b的.h文
C++的前置声明
FG2006的专栏
03-09 9589
<br /> <br />转自：http://blog.csdn.net/fjb2080/archive/2010/04/27/5533514.aspx 作者：清林，博客名：飞空静渡<br />刚开始学习c++的人都会遇到这样的问题：<br />定义一个类 class A，这个类里面使用了类B的对象b，然后定义了一个类B，里面也包含了一个类A的对象a，就成了这样：<br /> //a.h  #include "b.h"  class A  {  ....  private:      B b;  };  /
【C++】类的前置声明
xiaoyu_wu的博客
10-27 1990
两个类要互相引用，就会出现“未定义”尴尬，此时可以用前置声明来解决。 class person; //类的前置声明 class Animal { public: void eat(person& pn); }; class person { public: friend Animal::eat(person& pn); }； 但前置声明不包括类的详细信息，所以编译器无法得到前置声明类的size，成员等详细信息，不能试图通过前置声明解决类成员的调用。不能试图通
C++类的前置声明
JoeWANG93的博客
08-29 348
今天在研究C++”接口与实现分离“的时候遇到了一个问题，看似很小，然后背后的东西确值得让人深思！感觉在学习的过程中有太多的为什么，而每一个为什么背后都隐藏着一些原理和目的，所以得多问自己”为什么“，这样才不仅知其然，更知其所以然，才能举一反三、融会贯通，这也是我以前学习不够重视的一个问题，好在”亡羊补牢，犹未晚也！“。         C++中将”接口与实现分离“的两个重要目的就是”降低文件间的
c++类的前置声明
倾耳听的博客
01-04 194
class a; class B { public: B(){} a *c; }; int i = 9; class a { public: void print() { cout << "hello" << endl; } }; int main(int argc, char** argv) { B b; b.c->pri
【从 C 向 C++ 进阶】- 类 - 17. 类的提前声明
Kong
07-24 2109
从 C 向 C++ 进阶系列导航 1. 问题描述 在我做类型转换函数博文中最后的实验时，一直遇到了 “error: invalid use of incomplete type ‘class Test_B’” 这个编译错误，报错的源码如下： class Test_B; class Test_A { private: int m_var; public: Test_A(int num) ...
C++ 包含类两个类互相调用彼此的类成员变量和方法
09-13
1. 前置声明：在类A中使用类B的成员之前，我们需要告诉编译器类B的存在。这可以通过前置声明来实现： ```cpp class B; //前置声明 class A { B* b_ptr; // A中使用B的指针 }; ``` 2. 循环包含：如果类A包含类B的...
C++之类和对象
m0_62633482的博客
03-05 509
C++类和对象（2w字详解）
C++类的生存周期
Kevinonlie的博客
03-15 3220
众所周知，类是C++的核心，而对于类的生存周期的长短是受到很多因素影响，在这里我从以下几个方面来分析： 类在.data段生成时的生存周期 类在栈区生成时的生存周期 类在堆区生成时的生存周期 为了体现各种情况下类的生存周期，我们写一个测试用例来直观地感受。 class CGoods//实现三种构造方式 一个拷贝构造函数 一个赋值运算符重载 { public: CGoods(char* name...
C++类（一）——前置声明
一直走，不要回头
06-26 882
忙完毕业的事情了。更新继续！ 前置声明 转自——C++类的前置声明- King先生 - 博客园 链接整理 1、出错代码 //错误代码。报错：error C2079: 'b' uses undefined class 'B' class B; class A{ public: B b; }; class B{ public:...
C++ 前置声明
bigchen
08-04 1560
问题 最近遇到了两个类A、B相互调用的情况，于是想当然的在两个类A和B的头文件中 #include 了所需的头文件，当然结果编译报错了。为什么呢，A需要B，B需要A，形成了循环，违反了程序的确定性原则。代码如下图所示： 如这样相互包含的问题，可以使用前置声明来解决。即：在头文件中声明该类，在实现文件中包含该类。如下图所示： 解析 为什么这样使用前置声明，即在AAA.h中声明class BBB; 在BBB.h中声明class AAA; 且成员变量写为所声明类的指针变量， 便不会产生相互包含的错误呢？ 原因
c++ 前置声明
baidu_16370559的博客
09-29 4517
#pragma onceclass bar; class foo { public: Bar getBar(); private Bar* _bar; }; 即：在.h文件中用class 声明代替include头文件 前置声明只能作为指针或引用，不能定义类的对象，自然也就不能调用对象中的方法了。 前置声明要求： 1.其声明的类是文件所声明的类的数据成员时，是指针成员或引用成员（而不是对象成员）； 2.其声明的类是文件所声明的类的成员函数的参数或返回值时，该函数在文件中不存在定义。 ...
C++前置声明
斯坦福-MIT-Harvard-CMU
05-23 1192
通过使用前置声明，可以在头文件中仅引用被依赖的类型、函数或变量的存在，而不是包含完整的定义，从而解决了循环依赖问题。如果一个头文件中只包含了前置声明而不包含完整的定义，那么在包含该头文件时，编译器只需要知道该类型、函数或变量的存在即可，无需读取和解析完整的定义。总的来说，前置声明可以在头文件之间建立一种更松散的耦合关系，减少了头文件的包含和编译器的工作量，从而提高了编译速度和可维护性。通过使用前置声明，我们可以将类型、函数或变量的声明提前到需要使用它们的地方，而不需要提供完整的定义。
c++的前置声明
janeqi1987的专栏
11-30 497
 一、正文 定义一个类 class A，这个类里面使用了类B的对象b，然后定义了一个类B，里面也包含了一个类A的对象a，就成了这样： //a.h #include "b.h" class A { .... private: B b; };//b.h #include "a.h" class B { .... private:
C++中类的前置声明
UmdCoding的博客
08-01 832
转载：http://www.cnblogs.com/King-Gentleman/p/5081159.html一、类嵌套的疑问假设我们有两个类A和B，定义在一个.H文件中，但是在A中要用到B，B中也要用到A，但是这样的写法当然是错误的： #ifndef _TEST__ #define _TEST__class B; class A{ private: B b; }; class B{ pri
C++类的声明前置
最新发布
05-29
在 C++ 中，可以使用类的声明前置（forward declaration）来解决互相依赖的类之间的编译问题。类的声明前置可以让编译器知道某个类的存在，而无需包含该类的头文件。 具体来说，如果一个类 A 依赖于另一个类 B，而类 B 又依赖于类 A，那么在定义这两个类时，就会产生循环依赖的问题。此时，我们可以使用类的声明前置来解决这个问题。 例如，假设有两个类 `ClassA` 和 `ClassB`，它们互相依赖，可以这样来声明前置： ```cpp // ClassA.h 文件 #pragma once // 前置声明 ClassB class ClassB; class ClassA { public: void func(ClassB* b); }; // ClassB.h 文件 #pragma once // 前置声明 ClassA class ClassA; class ClassB { public: void func(ClassA* a); }; ``` 在上面的代码中，我们使用了 `class ClassB;` 和 `class ClassA;` 来声明前置，而不是包含类的头文件。这样，编译器就能够知道这两个类的存在，从而解决了循环依赖的问题。 需要注意的是，如果使用了类的声明前置，那么只能在函数参数、函数返回值或者指针成员变量等地方使用这个类。如果需要使用该类的具体实现，还需要包含该类的头文件。例如，在 `ClassA.cpp` 文件中实现 `ClassA` 的成员函数时，需要包含 `ClassB.h` 头文件： ```cpp // ClassA.cpp 文件 #include "ClassA.h" #include "ClassB.h" void ClassA::func(ClassB* b) { // 使用 ClassB 的具体实现 } ``` 总之，类的声明前置可以解决互相依赖的类之间的编译问题，提高代码的可读性和可维护性。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值