《深度探索C++对象模型》之《构造函数语义学》章节探索与理解

构造函数语义学

这一章原书主要分析了：编译器关于对象构造过程的干涉，即在对象构造这个过程中，编译器到底在背后做了什么

这一章的重点在于default constructor和copy constructor的相关知识

Default Constructor

一些C++的书籍中告诉我们：如果不写任何构造函数，那么编译器会为我们生成一个默认构造函数（default constructor）

那么，针对这个观点，有两个问题：

  • 这句话是正确的吗？
  • 如果这句话是正确的，那么编译器为我们生成的default constructor里有什么动作吗？

1 这句话是正确的吗？

这句话大体是正确的，但是cppreference中有更详细的说明：

隐式声明的默认构造函数
若不对类类型（struct、class?或?union）提供任何用户声明（user-declared）的构造函数，则编译器将始终声明一个作为其类的?inline public?成员的默认构造函数

隐式定义的默认构造函数
若隐式声明的默认构造函数未被定义为弃置的，则当其被ODR 式使用时，它为编译器所定义（即生成函数体并编译之），且它与拥有空函数体和空初始化器列表的用户定义的构造函数有严格相同的效果。即它调用这个类的各基类和各非静态成员的默认构造函数

有没有什么证据能证明编译器真的隐式定义了一个默认构造函数呢？有，考虑如下的一个类：

class A {};

这个类中没有任何成员变量或者成员函数，此时打印出该类的相关信息如下：

// clang -cc1 -fdump-record-layouts -emit-llvm main.cpp 命令
*** Dumping AST Record Layout
         0 | class A (empty)
           | [sizeof=1, dsize=1, align=1,
           |  nvsize=1, nvalign=1]

*** Dumping IRgen Record Layout
Record: CXXRecordDecl 0x55c6626abc70 <main.cpp:1:1, line:3:1> line:1:7 referenced class A definition
|-DefinitionData pass_in_registers empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
| |-DefaultConstructor exists trivial constexpr defaulted_is_constexpr
| |-CopyConstructor simple trivial has_const_param implicit_has_const_param
| |-MoveConstructor exists simple trivial
| |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
| |-MoveAssignment exists simple trivial needs_implicit
| `-Destructor simple irrelevant trivial needs_implicit
|-CXXRecordDecl 0x55c6626abd88 <col:1, col:7> col:7 implicit class A
|-CXXConstructorDecl 0x55c6626ac020 <col:7> col:7 implicit used constexpr A 'void () noexcept' inline default trivial
| `-CompoundStmt 0x55c6626ac4b8 <col:7>
|-CXXConstructorDecl 0x55c6626ac158 <col:7> col:7 implicit constexpr A 'void (const A &)' inline default trivial noexcept-unevaluated 0x55c6626ac158
| `-ParmVarDecl 0x55c6626ac268 <col:7> col:7 'const A &'
`-CXXConstructorDecl 0x55c6626ac308 <col:7> col:7 implicit constexpr A 'void (A &&)' inline default trivial noexcept-unevaluated 0x55c6626ac308
  `-ParmVarDecl 0x55c6626ac418 <col:7> col:7 'A &&'

Layout: <CGRecordLayout
  LLVMType:%class.A = type { i8 }
  NonVirtualBaseLLVMType:%class.A = type { i8 }
  IsZeroInitializable:1
  BitFields:[
]>

DefaultConstructor exists trivial constexpr defaulted_is_constexpr这一行证明了这个类存在一个default constructor且是trivial的，而我们并没有声明和定义，那么自然是编译器为我们自动生成的

2 隐式定义的默认构造函数里发生了什么？

在解决这个问题之前，首先有需要了解一些额外的知识：

default constructor是分为trivial default constructor（平凡默认构造函数，即不进行任何构造动作）和non trivial default constructor（非平凡默认构造函数）

什么情况下default constructor是trivial的呢？cppreference中说明了这一点：

当下列各项全部为真时，类 T 的默认构造函数为平凡的（平凡默认构造函数是不进行任何动作的构造函数。）：
构造函数并非用户提供（即为隐式定义或于其首个声明中预置的）
T 没有虚成员函数
T 没有虚基类
T 没有拥有默认初始化器的非静态数据成员。
每个 T 的直接基类都拥有平凡默认构造函数
每个类类型的非静态成员都拥有平凡默认构造函数

注意上述条件中的第一点也说明了一个事实：如果构造函数是用户定义的，那么必定是非平凡的

再回到隐式定义的默认构造函数里发生了什么？这个问题，就需要从两个角度来考虑了：

  1. 当编译器隐式定义的默认构造函数是一个trivial default constructor时，那么该trivial default constructor什么也不做
  2. 那么当编译器隐式定义的默认构造函数是一个non-trivial default constructor时，该non-trivial default constructor调用这个类的各基类和各非静态成员的默认构造函数

通过以上，我们已经知道了编译器在特定情况下，真的会隐式定义一个default constructor，也知道了在哪些情况下产生的default constructor是trivial的，那么再来详细的讨论一下，什么情况下，编译器生成的default constructor是non-trivial的

  1. 带有default constructor的member class object
    如果一个class A没有任何的constructor，但是它内含一个member object，而该member object拥有non-trivial default constructor，那么编译器为这个class隐式定义的default constructor是non-trivial。为什么呢？因为编译器为该class A产生的default constructor里必须要调用member object的non-trivial default constructor，否则无法完整的构造class A的对象
    仍然用代码来证明：

     class B {
  private:
   int b;
  public:
   B() {}
 };

 class A {
  private:
   B b;
     int a;
 };

    打印出class A的相关信息，如下：

     *** Dumping AST Record Layout
          0 | class B
          0 |   int b
            | [sizeof=4, dsize=4, align=4,
            |  nvsize=4, nvalign=4]

 *** Dumping AST Record Layout
          0 | class A
          0 |   class B b
          0 |     int b
          4 |   int a
            | [sizeof=8, dsize=8, align=4,
            |  nvsize=8, nvalign=4]

 *** Dumping IRgen Record Layout
 Record: CXXRecordDecl 0x55ba37562c50 <main.cpp:1:1, line:6:1> line:1:7 referenced class B definition
 |-DefinitionData pass_in_registers standard_layout trivially_copyable has_user_declared_ctor can_const_default_init
 | |-DefaultConstructor exists non_trivial user_provided
 | |-CopyConstructor simple trivial has_const_param implicit_has_const_param
 | |-MoveConstructor exists simple trivial
 | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
 | |-MoveAssignment exists simple trivial needs_implicit
 | `-Destructor simple irrelevant trivial
 |-CXXRecordDecl 0x55ba37562d68 <col:1, col:7> col:7 implicit referenced class B
 |-AccessSpecDecl 0x55ba37562df8 <line:2:2, col:9> col:2 private
 |-FieldDecl 0x55ba37562e38 <line:3:3, col:7> col:7 b 'int'
 |-AccessSpecDecl 0x55ba37562e88 <line:4:2, col:8> col:2 public
 |-CXXConstructorDecl 0x55ba37562f38 <line:5:3, col:8> col:3 used B 'void ()'
 | `-CompoundStmt 0x55ba37562ff8 <col:7, col:8>
 |-CXXDestructorDecl 0x55ba37563590 <line:1:7> col:7 implicit ~B 'void ()' inline default trivial noexcept-unevaluated 0x55ba37563590
 |-CXXConstructorDecl 0x55ba375636c8 <col:7> col:7 implicit constexpr B 'void (const B &)' inline default trivial noexcept-unevaluated 0x55ba375636c8
 | `-ParmVarDecl 0x55ba375637d8 <col:7> col:7 'const B &'
 `-CXXConstructorDecl 0x55ba37563878 <col:7> col:7 implicit constexpr B 'void (B &&)' inline default trivial noexcept-unevaluated 0x55ba37563878
   `-ParmVarDecl 0x55ba37563988 <col:7> col:7 'B &&'

 Layout: <CGRecordLayout
   LLVMType:%class.B = type { i32 }
   NonVirtualBaseLLVMType:%class.B = type { i32 }
   IsZeroInitializable:1
   BitFields:[
 ]>

 *** Dumping IRgen Record Layout
 Record: CXXRecordDecl 0x55ba37563008 <main.cpp:8:1, line:12:1> line:8:7 referenced class A definition
 |-DefinitionData pass_in_registers standard_layout trivially_copyable
 | |-DefaultConstructor exists non_trivial
 | |-CopyConstructor simple trivial has_const_param implicit_has_const_param
 | |-MoveConstructor exists simple trivial
 | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
 | |-MoveAssignment exists simple trivial needs_implicit
 | `-Destructor simple irrelevant trivial needs_implicit
 |-CXXRecordDecl 0x55ba37563128 <col:1, col:7> col:7 implicit class A
 |-AccessSpecDecl 0x55ba375631b8 <line:9:2, col:9> col:2 private
 |-FieldDecl 0x55ba375631f0 <line:10:3, col:5> col:5 b 'B'
 |-FieldDecl 0x55ba37563258 <line:11:3, col:7> col:7 a 'int'
 |-CXXConstructorDecl 0x55ba375634b0 <line:8:7> col:7 implicit used A 'void () noexcept(false)' inline default
 | |-CXXCtorInitializer Field 0x55ba375631f0 'b' 'B'
 | | `-CXXConstructExpr 0x55ba37592090 <col:7> 'B' 'void ()'
 | `-CompoundStmt 0x55ba375920e8 <col:7>
 |-CXXConstructorDecl 0x55ba375639f8 <col:7> col:7 implicit constexpr A 'void (const A &)' inline default trivial noexcept-unevaluated 0x55ba375639f8
 | `-ParmVarDecl 0x55ba37591e30 <col:7> col:7 'const A &'
 `-CXXConstructorDecl 0x55ba37591ec8 <col:7> col:7 implicit constexpr A 'void (A &&)' inline default trivial noexcept-unevaluated 0x55ba37591ec8
   `-ParmVarDecl 0x55ba37591fd8 <col:7> col:7 'A &&'

 Layout: <CGRecordLayout
   LLVMType:%class.A = type { %class.B, i32 }
   NonVirtualBaseLLVMType:%class.A = type { %class.B, i32 }
   IsZeroInitializable:1
   BitFields:[
 ]>

    DefaultConstructor exists non_trivial user_provided

    这一行中说明class B是用户定义的一个default constructor，是non-trivial的

    DefaultConstructor exists non_trivial

    第二行中则说明class A的default constructor也是存在的且是non-trivial的。在这个non-trivial default constructor中，编译器会调用class B的default constructor来初始化class A的对象中的b成分，但是不会初始化a（编译器看来，初始化b是它的工作，但是初始化a是程序员的工作）

    |-CXXConstructorDecl 0x55ba375634b0 col:7 implicit used A ‘void () noexcept(false)‘ inline default
    | |-CXXCtorInitializer Field 0x55ba375631f0 ‘b‘ ‘B‘
    | | -CXXConstructExpr 0x55ba37592090 <col:7> ‘B‘ ‘void ()‘ |-CompoundStmt 0x55ba375920e8

    这一段则说明了在class A的default constructor中调用了class B的default constructor

    如果，class A中提供了一个default constructor，那么编译器会怎么办呢？

     class B {
  private:
   int b;
  public:
   B() {}
 };

 class A {
  private:
   B b;
   int a;
  public:
   A() {
     a = 0;
   }
 };

    打印相关信息如下：

     *** Dumping AST Record Layout
          0 | class B
          0 |   int b
            | [sizeof=4, dsize=4, align=4,
            |  nvsize=4, nvalign=4]

 *** Dumping AST Record Layout
          0 | class A
          0 |   class B b
          0 |     int b
          4 |   int a
            | [sizeof=8, dsize=8, align=4,
            |  nvsize=8, nvalign=4]

 *** Dumping IRgen Record Layout
 Record: CXXRecordDecl 0x5641e5965d20 <main.cpp:1:1, line:6:1> line:1:7 referenced class B definition
 |-DefinitionData pass_in_registers standard_layout trivially_copyable has_user_declared_ctor can_const_default_init
 | |-DefaultConstructor exists non_trivial user_provided
 | |-CopyConstructor simple trivial has_const_param implicit_has_const_param
 | |-MoveConstructor exists simple trivial
 | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
 | |-MoveAssignment exists simple trivial needs_implicit
 | `-Destructor simple irrelevant trivial
 |-CXXRecordDecl 0x5641e5965e38 <col:1, col:7> col:7 implicit referenced class B
 |-AccessSpecDecl 0x5641e5965ec8 <line:2:2, col:9> col:2 private
 |-FieldDecl 0x5641e5965f08 <line:3:3, col:7> col:7 b 'int'
 |-AccessSpecDecl 0x5641e5965f58 <line:4:2, col:8> col:2 public
 |-CXXConstructorDecl 0x5641e5966008 <line:5:3, col:8> col:3 used B 'void ()'
 | `-CompoundStmt 0x5641e59660c8 <col:7, col:8>
 |-CXXConstructorDecl 0x5641e59664e8 <line:1:7> col:7 implicit constexpr B 'void (const B &)' inline default trivial noexcept-unevaluated 0x5641e59664e8
 | `-ParmVarDecl 0x5641e59665f8 <col:7> col:7 'const B &'
 |-CXXConstructorDecl 0x5641e5966698 <col:7> col:7 implicit constexpr B 'void (B &&)' inline default trivial noexcept-unevaluated 0x5641e5966698
 | `-ParmVarDecl 0x5641e59667a8 <col:7> col:7 'B &&'
 `-CXXDestructorDecl 0x5641e59953b8 <col:7> col:7 implicit ~B 'void ()' inline default trivial noexcept-unevaluated 0x5641e59953b8

 Layout: <CGRecordLayout
   LLVMType:%class.B = type { i32 }
   NonVirtualBaseLLVMType:%class.B = type { i32 }
   IsZeroInitializable:1
   BitFields:[
 ]>

 *** Dumping IRgen Record Layout
 Record: CXXRecordDecl 0x5641e59660d8 <main.cpp:8:1, line:16:1> line:8:7 referenced class A definition
 |-DefinitionData pass_in_registers standard_layout trivially_copyable has_user_declared_ctor can_const_default_init
 | |-DefaultConstructor exists non_trivial user_provided
 | |-CopyConstructor simple trivial has_const_param implicit_has_const_param
 | |-MoveConstructor exists simple trivial
 | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
 | |-MoveAssignment exists simple trivial needs_implicit
 | `-Destructor simple irrelevant trivial needs_implicit
 |-CXXRecordDecl 0x5641e59661f8 <col:1, col:7> col:7 implicit referenced class A
 |-AccessSpecDecl 0x5641e5966288 <line:9:2, col:9> col:2 private
 |-FieldDecl 0x5641e59662c0 <line:10:3, col:5> col:5 b 'B'
 |-FieldDecl 0x5641e5966328 <line:11:3, col:7> col:7 referenced a 'int'
 |-AccessSpecDecl 0x5641e5966378 <line:12:2, col:8> col:2 public
 |-CXXConstructorDecl 0x5641e5966400 <line:13:3, line:15:3> line:13:3 used A 'void ()'
 | |-CXXCtorInitializer Field 0x5641e59662c0 'b' 'B'
 | | `-CXXConstructExpr 0x5641e5966818 <col:3> 'B' 'void ()'
 | `-CompoundStmt 0x5641e59668f0 <col:7, line:15:3>
 |   `-BinaryOperator 0x5641e59668d0 <line:14:5, col:9> 'int' lvalue '='
 |     |-MemberExpr 0x5641e5966880 <col:5> 'int' lvalue ->a 0x5641e5966328
 |     | `-CXXThisExpr 0x5641e5966870 <col:5> 'A *' implicit this
 |     `-IntegerLiteral 0x5641e59668b0 <col:9> 'int' 0
 |-CXXConstructorDecl 0x5641e5966b18 <line:8:7> col:7 implicit constexpr A 'void (const A &)' inline default trivial noexcept-unevaluated 0x5641e5966b18
 | `-ParmVarDecl 0x5641e5995348 <col:7> col:7 'const A &'
 `-CXXConstructorDecl 0x5641e59954c8 <col:7> col:7 implicit constexpr A 'void (A &&)' inline default trivial noexcept-unevaluated 0x5641e59954c8
   `-ParmVarDecl 0x5641e59955d8 <col:7> col:7 'A &&'

 Layout: <CGRecordLayout
   LLVMType:%class.A = type { %class.B, i32 }
   NonVirtualBaseLLVMType:%class.A = type { %class.B, i32 }
   IsZeroInitializable:1
   BitFields:[
 ]>

    |-CXXConstructorDecl 0x5641e5966400 <line:13:3, line:15:3> line:13:3 used A ‘void ()‘
    | |-CXXCtorInitializer Field 0x5641e59662c0 ‘b‘ ‘B‘
    | | `-CXXConstructExpr 0x5641e5966818 ‘B‘ ‘void ()‘

    可以发现，在我们定义的default constructor中，也调用了class B的default constructor，且这个调用动作发生在 a = 0;这条语句之前，然而我们并没有写呀，这便是编译器自动安插的调用

    也就是说，在这种情况下，编译器会扩充已经存在constructor，在其中安插一些代码，使得在该constgructor中所有代码执行之前，先调用必要的default constructor

// 未完，待续...

原文地址：https://www.cnblogs.com/xhb19960928/p/11688972.html

时间： 2024-10-28 14:41:49

《深度探索C++对象模型》之《构造函数语义学》章节探索与理解的相关文章

【深度探索c++对象模型】Function语义学之虚函数

虚函数的一般实现模型:每一个class有一个virtual table,内含该class之中有作用的virtual function的地址,然后每个object有一个vptr,指向virtual table. 识别class是否支持多态,唯一恰当的方法是看它是否有virtual function,只要class拥有virtual function,它就需要额外的执行期信息. 考虑ptr->z(),ptr是基类指针,z是虚函数,为了找到并调用z()的适当实体,我们需要两项信息: 1.ptr所指对象

【深度探索C++对象模型】data语义学

class X{}; class Y :public virtual X{}; class Z :public virtual X{}; class A :public Y, public Z{}; void main() { cout << sizeof(X) << " " << sizeof(Y) << " " << sizeof(Z) << " " << s

深入探索C++对象模型--C++构造函数

C++构造函数语意 对象构造过程中编译器的干预原则和方法. Default constructor的构建方法 经常会提到default constructor,那么什么时候才会合成出一个default consgtructor呢?当编译器需要它的时候.别合成出来的constructor值执行编译器所需的行动. 如果一个class没有任何constructor,但它内含一个成员对象,这个成员对象有default constructor,编译器需要为此class合成出一个defautl constr

深度探索C++对象模型 第二章构造函数语意学

在使用C++时,常常会好奇或者抱怨,编译器为我们做了什么事呢? 为什么构造函数没有为我初始化呢?为什么我还要写默认构造函数呢? 2.1 Default Constructor 的构造操作 如果没有声明默认构造函数,编译器会在需要的时候帮我们产生出来. 为了避免在多个地方被需要导致重复,则编译器将产生的构造函数声明为inline方式. class Foo {public:Foo(), Foo(int) }; class Bar {public: Foo foo;char *str;} Bar ba

【深度探索C++对象模型】第二章 构造函数语意学(上)

第二章 构造函数语意学(The Semantics of Constructors) -- 本书作者:Stanley B.Lippman 一.前言 首先让我们来梳理一个概念: 默认构造函数(Default Constructor) : 是在没有显示提供初始化式时调用的构造函数.它由不带任何参数的构造函数,或是为所有形参提供默认实参的构造函数定义.如果定义的某个类的成员变量没有提供显示的初始化式时,就会调用默认构造函数(Default Contructor). 如果用户的类里面,没有显示的定义任何

【深度探索C++对象模型】第一章 关于对象

第一章 关于对象(Object Lessons) -- 本书作者:Stanley B.Lippman 一.前言 什么是 C++ 对象模型:简单的说,就是 C++ 中面向对象的底层实现机制. 本书组织: 第 1 章,关于对象(Object Lessons),介绍 C++ 对象的基础概念,给读者一个粗略的了解. 第 2 章,构造函数语意学(The Semantics of Constructors),构造函数什么时候会被编译器合成?它给我们的程序效率带来了怎样的影响? 第 3 章,Data语意学(T

[读书系列] 深度探索C++对象模型 初读

2012年底-2014年初这段时间主要用C++做手游开发,时隔3年,重新拿起<深度探索C++对象模型>这本书,感觉生疏了很多,如果按前阵子的生疏度来说,现在不借助Visual Studio之类的工具的话,写C++代码感觉要比较费劲,最近重读了这本书后,感觉要写点东西下来(因为懒得用笔作笔记,太慢了-_-!)加深下印象. 以前还是新手的时候,总是认为: 1.class如果没有定义任何constructor的话,编译器会自动合成一个default constructor(我习惯叫缺省的构造函数)出

深度探索C++对象模型 第三章 Data 语意学

一个有趣的问题:下列 类 sizeof大小 class X{}    //1 class Y:public virtual X{} //4 or 8 class Z:public virtual X{} // 4 or 8 class A:public Y,public Z{} // 8 or 12 主要原因:为了保持每一个类生成对象在内存中的唯一性,编译器必须要给空类生成一个char来维持object的唯一性: 而virtual继承中,仅保持了base class的指针,有些编译器会继承bas

深度探索C++对象模型 第五章 构造、析构、拷贝语意学

1. const 成员函数需要吗? 尽量不要,如果存在继承,则无法预支子类是否有可能改变data member 2. pure virtual constructor 可以实现类的隐藏吗(包含data member)?   这样子类无法调用base 的构造函数对数据初始化,所以可以用protected来实现构造函数,可以实现子类调用: 3. 如果class中存在virtual function,则编译器会再构造函数中对vptr进行初始化(在base构造函数调用之后,而代码实现之前) 4.拷贝构造