C++构造函数语意学——默认拷贝构造函数

电玩女神 2022-08-07 03:40 251阅读 0赞

## 概述 ##

使用 class object 时，在以下三种情况会以一个 object 的内容作为另一个 class object 的初值，即用到拷贝构造函数：

1.  定义一个 class object 并对其进行初始化；
2.  class object 作为一个参数传递给函数；
3.  class object 作为函数的返回值；

若用户没有显示声明或定义拷贝构造函数，则 C++ 在 **必要** 时为 class 声明或定义隐式拷贝构造函数，若出现以下的情况时，该拷贝构造函数是 trivial 的：

> 1.  their class has no virtual functions and no virtual base class(es).
> 2.  all direct base classes and non-static data members of their class have trivial constructors.
> 3.  Otherwise, the copy constructor are non-trivial. Implicitly-declared non-trivial copy constructor.

## 默认拷贝构造函数 ##

在以下四种情况下，编译器会合成一个 non-trivial 的默认拷贝构造函数：

1.  当 class 内含一个具有 copy constructor 的 member object；
2.  当 class 继承自一个具有 copy constructor 的 base class；
3.  当 class 声明有 virtual functions；
4.  当 class 派生自 virtual base class(es)；

前面两种情况，编译器必须将 member 或 base class 的 copy constructor 放置在默认拷贝构造函数中，以下例子同时满足这两个情况：

#include <iostream>
    
    using namespace std;
    
    class Foo {
    public:
        Foo() {}
        Foo(const Foo &foo) { cout << "Foo's copy construct!" << endl; }
    };
    
    class Word: public Foo {
    public:
    
        int x;
        Foo foo;
    };
    
    int main()
    {
        Word ba;
        Word bb = ba;
        return 0;
    }

执行结果：编译器在合成的拷贝构造函数中调用了两次 Foo 类的拷贝构造函数；

(gdb) r
    Starting program: ./test02 
    
    Breakpoint 1, main () at test02.cpp:20
    20      Word ba;
    (gdb) s
    Word::Word (this=0xbffff020) at test02.cpp:11
    11  class Word: public Foo {
    (gdb) s
    Foo::Foo (this=0xbffff020) at test02.cpp:7
    7       Foo() {}
    (gdb) s
    Foo::Foo (this=0xbffff024) at test02.cpp:7
    7       Foo() {}
    (gdb) s
    main () at test02.cpp:21
    21      Word bb = ba;
    (gdb) s
    Word::Word (this=0xbffff028) at test02.cpp:11
    11  class Word: public Foo {
    (gdb) s
    Foo::Foo (this=0xbffff028, foo=...) at test02.cpp:8
    8       Foo(const Foo &foo) { cout << "Foo's copy construct!" << endl; }
    (gdb) s
    Foo's copy construct!
    Foo::Foo (this=0xbffff02c, foo=...) at test02.cpp:8
    8       Foo(const Foo &foo) { cout << "Foo's copy construct!" << endl; }
    (gdb) s
    Foo's copy construct!
    main () at test02.cpp:22
    22      return 0;
    (gdb) s
    23  }
    (gdb)

第三种情况，若是相同 class 的 object 直接的初始化，可以采用 bitwise copy 方式进行，因为 vptr 指向相同的虚函数表；若是使用派生类 object 初始化 基类 object 时，则编译器会重新设定 class object 的 virtual table 的指针，因为不同类的 vptr 指向各自的虚函数表；

#include <iostream>
    
    using namespace std;
    
    class Foo {
    public:
        virtual void func()
        { cout << "virtual function in Foo!" << endl; }
    };
    
    class Word: public Foo {
    public:
        void func()
        { cout << "virtual function in Word!" << endl; }
    };
    int main()
    {
        Word b1;
        Word b2 = b1;    // 相同类对象之间初始化，vptr直接复制，指向相同的virtual function table
        b2.func();
    
        Foo foo = b1;   // 不同类对象之间初始化，发生切割，vptr不直接复制，指向不同的virtual function table
        foo.func();
        return 0;
    }

执行结果：

(gdb) b 19
    Breakpoint 1 at 0x8048809: file test03.cpp, line 19.
    (gdb) r
    Starting program: /home/nifengweijifen/linuxStudy/ObjectModel/chap02/test03 
    
    Breakpoint 1, main () at test03.cpp:19
    19      Word b1;
    (gdb) s
    Word::Word (this=0xbffff024) at test03.cpp:12
    12  class Word: public Foo {
    (gdb) s
    Foo::Foo (this=0xbffff024) at test03.cpp:6
    6   class Foo {
    (gdb) s
    main () at test03.cpp:20
    20      Word b2 = b1;    //相同类之间的初始化，直接复制 vptr，指向相同的virtual function table
    (gdb) s
    Word::Word (this=0xbffff028) at test03.cpp:12
    12  class Word: public Foo {
    (gdb) s
    Foo::Foo (this=0xbffff028) at test03.cpp:6
    6   class Foo {
    (gdb) s
    main () at test03.cpp:21
    21      b2.func();
    (gdb) s
    Word::func (this=0xbffff028) at test03.cpp:15
    15      { cout << "virtual function in Bar!" << endl; }
    (gdb) s
    virtual function in Word!
    main () at test03.cpp:23
    23      Foo foo = b1;   // 不同类之间的初始化，发生切割，vptr不直接复制，指向不同的virtual function table
    (gdb) s
    Foo::Foo (this=0xbffff02c) at test03.cpp:6
    6   class Foo {
    (gdb) s
    main () at test03.cpp:24
    24      foo.func();
    (gdb) s
    Foo::func (this=0xbffff02c) at test03.cpp:9
    9       { cout << "virtual function in Foo!" << endl; }
    (gdb) s
    virtual function in Foo!
    main () at test03.cpp:25
    25      return 0;
    (gdb) s
    26  }
    (gdb)

第四种情况和第三种情况相似，若是相同 class 的 object 直接的初始化，可以采用 bitwise copy 方式进行；若是使用派生类 object 初始化 基类 object 时，则编译器会重新设定 virtual base class 的指针；