C++空类编译器自动生成的6个成员函数

朱雀 2022-06-01 08:16 110阅读 0赞

# 一、问题    #

在C++中，编译器会为空类提供哪些默认成员函数？分别有什么样的功能呢？

# 二、详解 #

##     ##

## 1、空类，声明时编译器不会生成任何成员函数 ##

对于空类，编译器不会生成任何的成员函数，只会生成1个字节的占位符。

有时可能会以为编译器会为空类生成默认构造函数等，事实上是不会的，**编译器只会在需要的时候生成6个成员函数**：默认构造函数、默认拷贝构造函数、默认析构函数、默认赋值运算符 这四个是我们通常大都知道的。但是除了这四个，还有两个，那就是取址运算符和 取址运算符 const。

代码：

**\[html\]**  [view plain][]  [copy][view plain]

1.  \#include <iostream>  
2.  using namespace std;  
3.    
4.  class Empty\_one  
5.  \{  
6.  \};  
7.  class Empty\_two  
8.  \{\};  
9.  class Empty\_three  
10. \{  
11.     virtual void fun() = 0;  
12. \};  
13. class Empty\_four :  public Empty\_two, public Empty\_three  
14. \{  
15. \};  
16.   
17. int main()  
18. \{  
19.   cout<<"sizeof(Empty\_one):"<<sizeof(Empty\_one)<<endl;  
20.   cout<<"sizeof(Empty\_two):"<<sizeof(Empty\_two)<<endl;  
21.   cout<<"sizeof(Empty\_three):"<<sizeof(Empty\_three)<<endl;  
22.   cout<<"sizeof(Empty\_four):"<<sizeof(Empty\_four)<<endl;  
23.   return 0;  
24. \}

运行结果：

![Center][]

分析：

类Empty\_one、Empty\_two是空类，但空类同样可以被实例化，而每个实例在内存中都有一个独一无二的地址，为了达到这个目的，编译器往往会给一个空类隐含的加一个字节，这样空类在实例化后在内存得到了独一无二的地址，所以sizeof(Empty\_one)和sizeof(Empty\_two)的大小为1。

类Empty\_three里面因有一个纯虚函数，故有一个指向虚函数的指针（vptr），64位系统分配给指针的大小为8个字节，所以sizeof(Empty\_three)的大小为8。

类Empty\_four继承于Empty\_two和Empty\_three，编译器取消Empty\_two的占位符，保留一虚函数表，故大小为8。

## 2、空类，定义时会生成6个成员函数 ##

当空类Empty\_one定义一个对象时Empty\_one pt;sizeof(pt)仍是为1，但编译器会生成6个成员函数：一个缺省的构造函数、一个拷贝构造函数、一个析构函数、一个赋值运算符、两个取址运算符。

**\[html\]**  [view plain][]  [copy][view plain]

1.  class Empty  
2.  \{\};

等价于：

**\[html\]**  [view plain][]  [copy][view plain]

1.  class Empty  
2.  \{  
3.    public:  
4.      Empty();                            //缺省构造函数  
5.      Empty(const Empty &rhs);            //拷贝构造函数  
6.      ~Empty();                           //析构函数   
7.      Empty& operator=(const Empty &rhs); //赋值运算符  
8.      Empty\* operator&();                 //取址运算符  
9.      const Empty\* operator&() const;     //取址运算符(const版本)  
10. \};

使用时的调用情况：

**\[html\]**  [view plain][]  [copy][view plain]

1.  Empty \*e = new Empty();    //缺省构造函数  
2.  delete e;                  //析构函数  
3.  Empty e1;                  //缺省构造函数                                 
4.  const Empty e2(e1);        //拷贝构造函数  
5.  e2 = e1;                   //赋值运算符  
6.  Empty \*pe1 = &e1;          //取址运算符(非const)  
7.  const Empty \*pe2 = &e2;    //取址运算符(const)

C++编译器对这些函数的实现：

**\[html\]**  [view plain][]  [copy][view plain]

1.  inline Empty::Empty()                          //缺省构造函数  
2.  \{  
3.  \}  
4.  inline Empty::~Empty()                         //析构函数  
5.  \{  
6.  \}  
7.  inline Empty \*Empty::operator&()               //取址运算符(非const)  
8.  \{  
9.    return this;   
10. \}             
11. inline const Empty \*Empty::operator&() const    //取址运算符(const)  
12. \{  
13.   return this;  
14. \}  
15. inline Empty::Empty(const Empty &rhs)           //拷贝构造函数  
16. \{  
17.   //对类的非静态数据成员进行以"成员为单位"逐一拷贝构造  
18.   //固定类型的对象拷贝构造是从源对象到目标对象的"逐位"拷贝  
19. \}  
20.   
21. inline Empty& Empty::operator=(const Empty &rhs) //赋值运算符  
22. \{  
23.   //对类的非静态数据成员进行以"成员为单位"逐一赋值  
24.   //固定类型的对象赋值是从源对象到目标对象的"逐位"赋值。  
25. \}

例如：m是类C中的一个类型为T的非静态成员变量，若C没有声明拷贝构造函数（赋值运算符）， m将会通过T的拷贝构造函数（赋值运算符）被拷贝构造(赋值)；该规则递归应用到m的数据成员，直到找到一个拷贝构造函数（赋值运算符）或固定类型（例如：int、double、指针等)为止。

# 三、总结 #

（1）上述运行结果依赖于编译器和64位、32位不同的系统。

（2）本博文只是总结一些C++特性，也有无法理解的地方，不足之处还请指出，在此先感谢！

**本文转自：**

**http://blog.csdn.net/taiyang1987912/article/details/43485569**

[view plain]: http://blog.csdn.net/taiyang1987912/article/details/43485569#
[Center]: /images/20220601/b8fdedcf9def45bfa513e7452ba6d1c0.png