现代C++技术研究（6）---编译器自动生成移动构造函数的条件

已于 2023-05-19 22:58:52 修改
阅读量911 收藏 7
点赞数 1
分类专栏： C/C++技术 文章标签： c++ 开发语言
于 2023-05-19 22:55:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/swordmanwk/article/details/130774621
版权

C++11以后，支持移动构造函数和移动赋值运算符，这样语言特性明显提高了我们编写的程序的性能。一般来说，编译器会自动生成的移动构造函数，足够满足我们的使用需求，但是有些场景编译器不会自动生成移动构造函数，这会影响我们编写代码的性能。因此必须要识别出哪些场景编译器可以自动生成移动构造函数哪些场景不能。对于不能的场景，我们需要手工编写移动构造函数和移动赋值运算符。

场景1，如果我们在一个类里不手工编写任何构造函数，析构函数，拷贝赋值运算符和移动赋值运算符，编译器在需要的时候会给我们生成移动构造函数。例如：

#include <vector>

class A {
private:
    std::vector<int> vi_;
};

int main()
{
    A a;
    A b = std::move(a);
}

查看生成的汇编代码（ARM64 gcc13.1.0 --std=c++14），可以看到：

A::A() [base object constructor]:
        stp     x29, x30, [sp, -32]!
        mov     x29, sp
        str     x0, [sp, 24]
        ldr     x0, [sp, 24]
        bl      std::vector<int, std::allocator<int> >::vector() [complete object constructor]
        nop
        ldp     x29, x30, [sp], 32
        ret
A::~A() [base object destructor]:
        stp     x29, x30, [sp, -32]!
        mov     x29, sp
        str     x0, [sp, 24]
        ldr     x0, [sp, 24]
        bl      std::vector<int, std::allocator<int> >::~vector() [complete object destructor]
        nop
        ldp     x29, x30, [sp], 32
        ret
A::A(A&&) [base object constructor]:
        stp     x29, x30, [sp, -32]!
        mov     x29, sp
        str     x0, [sp, 24]
        str     x1, [sp, 16]
        ldr     x0, [sp, 24]
        ldr     x1, [sp, 16]
        bl      std::vector<int, std::allocator<int> >::vector(std::vector<int, std::allocator<int> >&&) [complete object constructor]
        nop
        ldp     x29, x30, [sp], 32
        ret

编译器自动生成了移动构造函数，该函数调用了vector<int>的移动构造函数。

场景2：我们编写默认构造函数：

#include <vector>

class A {
public:
    A() noexcept
    {
        vi_.resize(10);
    }
private:
    std::vector<int> vi_;
};

int main()
{
    A a;
    A b = std::move(a);
}

查看汇编代码：

A::A() [base object constructor]:
        stp     x29, x30, [sp, -32]!
        mov     x29, sp
        str     x0, [sp, 24]
        ldr     x0, [sp, 24]
        bl      std::vector<int, std::allocator<int> >::vector() [complete object constructor]
        ldr     x0, [sp, 24]
        mov     x1, 10
        bl      std::vector<int, std::allocator<int> >::resize(unsigned long)
        nop
        ldp     x29, x30, [sp], 32
        ret
A::~A() [base object destructor]:
        stp     x29, x30, [sp, -32]!
        mov     x29, sp
        str     x0, [sp, 24]
        ldr     x0, [sp, 24]
        bl      std::vector<int, std::allocator<int> >::~vector() [complete object destructor]
        nop
        ldp     x29, x30, [sp], 32
        ret
A::A(A&&) [base object constructor]:
        stp     x29, x30, [sp, -32]!
        mov     x29, sp
        str     x0, [sp, 24]
        str     x1, [sp, 16]
        ldr     x0, [sp, 24]
        ldr     x1, [sp, 16]
        bl      std::vector<int, std::allocator<int> >::vector(std::vector<int, std::allocator<int> >&&) [complete object constructor]
        nop
        ldp     x29, x30, [sp], 32
        ret

可以看到，移动构造函数仍然自动生成，所以，默认构造函数的定制，是没有影响的。

场景3：显示的声明析构函数：

#include <vector>

class A {
public:
    ~A() = default;
private:
    std::vector<int> vi_;
};

int main()
{
    A a;
    A b = std::move(a);
}

查看汇编结果：

A::A() [base object constructor]:
        stp     x29, x30, [sp, -32]!
        mov     x29, sp
        str     x0, [sp, 24]
        ldr     x0, [sp, 24]
        bl      std::vector<int, std::allocator<int> >::vector() [complete object constructor]
        nop
        ldp     x29, x30, [sp], 32
        ret
A::~A() [base object destructor]:
        stp     x29, x30, [sp, -32]!
        mov     x29, sp
        str     x0, [sp, 24]
        ldr     x0, [sp, 24]
        bl      std::vector<int, std::allocator<int> >::~vector() [complete object destructor]
        nop
        ldp     x29, x30, [sp], 32
        ret
A::A(A const&) [base object constructor]:
        stp     x29, x30, [sp, -32]!
        mov     x29, sp
        str     x0, [sp, 24]
        str     x1, [sp, 16]
        ldr     x0, [sp, 24]
        ldr     x1, [sp, 16]
        bl      std::vector<int, std::allocator<int> >::vector(std::vector<int, std::allocator<int> > const&) [complete object constructor]
        nop
        ldp     x29, x30, [sp], 32
        ret

可以看到，编译器自动生成的是拷贝构造函数，而不是移动构造函数了。

场景4：显示定义拷贝构造函数:

#include <vector>

class A {
public:
    A() = default;
    A(const A& a)
    {
        if (this == &a) {
            return;
        }
        vi_ = a.vi_;
    }
private:
    std::vector<int> vi_;
};

int main()
{
    A a;
    A b = std::move(a);
}

查看汇编代码：

A::A(A const&) [base object constructor]:
        stp     x29, x30, [sp, -48]!
        mov     x29, sp
        str     x19, [sp, 16]
        str     x0, [sp, 40]
        str     x1, [sp, 32]
        ldr     x0, [sp, 40]
        bl      std::vector<int, std::allocator<int> >::vector() [complete object constructor]
        ldr     x1, [sp, 40]
        ldr     x0, [sp, 32]
        cmp     x1, x0
        beq     .L9
        ldr     x0, [sp, 40]
        ldr     x1, [sp, 32]
        bl      std::vector<int, std::allocator<int> >::operator=(std::vector<int, std::allocator<int> > const&)
        b       .L4
        mov     x19, x0
        ldr     x0, [sp, 40]
        bl      std::vector<int, std::allocator<int> >::~vector() [complete object destructor]
        mov     x0, x19
        bl      _Unwind_Resume
.L9:
        nop
.L4:
        ldr     x19, [sp, 16]
        ldp     x29, x30, [sp], 48
        ret
A::A() [base object constructor]:
        stp     x29, x30, [sp, -32]!
        mov     x29, sp
        str     x0, [sp, 24]
        ldr     x0, [sp, 24]
        bl      std::vector<int, std::allocator<int> >::vector() [complete object constructor]
        nop
        ldp     x29, x30, [sp], 32
        ret
A::~A() [base object destructor]:
        stp     x29, x30, [sp, -32]!
        mov     x29, sp
        str     x0, [sp, 24]
        ldr     x0, [sp, 24]
        bl      std::vector<int, std::allocator<int> >::~vector() [complete object destructor]
        nop
        ldp     x29, x30, [sp], 32
        ret

可以看到，编译器没有自动生成移动构造函数。

场景5：显示定义拷贝赋值运算符：

#include <vector>

class A {
public:
    A() = default;
    A& operator = (const A& a)
    {
        if (this != &a) {
            vi_ = a.vi_;
        }
        return *this;
    }
private:
    std::vector<int> vi_;
};

int main()
{
    A a;
    A b = std::move(a);
}

查看汇编代码：

A::A() [base object constructor]:
        stp     x29, x30, [sp, -32]!
        mov     x29, sp
        str     x0, [sp, 24]
        ldr     x0, [sp, 24]
        bl      std::vector<int, std::allocator<int> >::vector() [complete object constructor]
        nop
        ldp     x29, x30, [sp], 32
        ret
A::~A() [base object destructor]:
        stp     x29, x30, [sp, -32]!
        mov     x29, sp
        str     x0, [sp, 24]
        ldr     x0, [sp, 24]
        bl      std::vector<int, std::allocator<int> >::~vector() [complete object destructor]
        nop
        ldp     x29, x30, [sp], 32
        ret
A::A(A const&) [base object constructor]:
        stp     x29, x30, [sp, -32]!
        mov     x29, sp
        str     x0, [sp, 24]
        str     x1, [sp, 16]
        ldr     x0, [sp, 24]
        ldr     x1, [sp, 16]
        bl      std::vector<int, std::allocator<int> >::vector(std::vector<int, std::allocator<int> > const&) [complete object constructor]
        nop
        ldp     x29, x30, [sp], 32
        ret

可以看到，编译器实际生成的是拷贝构造函数，没有生成移动构造函数。

场景6：显示定义移动构造函数，这种场景当然编译器不会自动生成移动构造函数，代码略。

场景7：显示定义移动赋值运算符，但是不定义移动构造函数场景，这种场景编译器也不会自动生成移动构造函数，而且还不会自动生成拷贝构造函数，下面的代码就编译不过了：

#include <vector>

class A {
public:
    A() = default;
    A& operator = (A&& a)
    {
        if (this != &a) {
            vi_ = std::move(a.vi_);
        }
        return *this;
    }
private:
    std::vector<int> vi_;
};

int main()
{
    A a;
    A b = std::move(a);
}

场景8：定义其他类型的构造函数，比如：

#include <vector>

class A {
public:
    A() = default;
    explicit A(int length) : vi_(length) {}
private:
    std::vector<int> vi_;
};

int main()
{
    A a;
    A b = std::move(a);
}

查看汇编代码：

A::A() [base object constructor]:
        stp     x29, x30, [sp, -32]!
        mov     x29, sp
        str     x0, [sp, 24]
        ldr     x0, [sp, 24]
        bl      std::vector<int, std::allocator<int> >::vector() [complete object constructor]
        nop
        ldp     x29, x30, [sp], 32
        ret
A::~A() [base object destructor]:
        stp     x29, x30, [sp, -32]!
        mov     x29, sp
        str     x0, [sp, 24]
        ldr     x0, [sp, 24]
        bl      std::vector<int, std::allocator<int> >::~vector() [complete object destructor]
        nop
        ldp     x29, x30, [sp], 32
        ret
A::A(A&&) [base object constructor]:
        stp     x29, x30, [sp, -32]!
        mov     x29, sp
        str     x0, [sp, 24]
        str     x1, [sp, 16]
        ldr     x0, [sp, 24]
        ldr     x1, [sp, 16]
        bl      std::vector<int, std::allocator<int> >::vector(std::vector<int, std::allocator<int> >&&) [complete object constructor]
        nop
        ldp     x29, x30, [sp], 32
        ret

可以看到，编译器自动生成了移动构造函数，也就是说，没有影响。

那么如果编译器没有自动生成移动构造函数，我们怎么解决这个问题，需要手工写一个吗？一般来说，是没有必要的，只要写一个默认的就可以了，比如：

#include <vector>

class A {
public:
    A() = default;
    virtual ~A() = default;
    A(A && a) = default;
    A& operator = ( A && a) = default;
private:
    std::vector<int> vi_;
};

int main()
{
    A a;
    A b = std::move(a);
}

这样，后面程序演进的时候，新增成员变量，不需要同步修改移动构造函数和移动赋值运算符，生成的完整汇编如下：

A::A() [base object constructor]:
        stp     x29, x30, [sp, -32]!
        mov     x29, sp
        str     x0, [sp, 24]
        adrp    x0, vtable for A+16
        add     x1, x0, :lo12:vtable for A+16
        ldr     x0, [sp, 24]
        str     x1, [x0]
        ldr     x0, [sp, 24]
        add     x0, x0, 8
        bl      std::vector<int, std::allocator<int> >::vector() [complete object constructor]
        nop
        ldp     x29, x30, [sp], 32
        ret
A::~A() [base object destructor]:
        stp     x29, x30, [sp, -32]!
        mov     x29, sp
        str     x0, [sp, 24]
        adrp    x0, vtable for A+16
        add     x1, x0, :lo12:vtable for A+16
        ldr     x0, [sp, 24]
        str     x1, [x0]
        ldr     x0, [sp, 24]
        add     x0, x0, 8
        bl      std::vector<int, std::allocator<int> >::~vector() [complete object destructor]
        nop
        ldp     x29, x30, [sp], 32
        ret
A::~A() [deleting destructor]:
        stp     x29, x30, [sp, -32]!
        mov     x29, sp
        str     x0, [sp, 24]
        ldr     x0, [sp, 24]
        bl      A::~A() [complete object destructor]
        mov     x1, 32
        ldr     x0, [sp, 24]
        bl      operator delete(void*, unsigned long)
        ldp     x29, x30, [sp], 32
        ret
A::A(A&&) [base object constructor]:
        stp     x29, x30, [sp, -32]!
        mov     x29, sp
        str     x0, [sp, 24]
        str     x1, [sp, 16]
        adrp    x0, vtable for A+16
        add     x1, x0, :lo12:vtable for A+16
        ldr     x0, [sp, 24]
        str     x1, [x0]
        ldr     x0, [sp, 24]
        add     x2, x0, 8
        ldr     x0, [sp, 16]
        add     x0, x0, 8
        mov     x1, x0
        mov     x0, x2
        bl      std::vector<int, std::allocator<int> >::vector(std::vector<int, std::allocator<int> >&&) [complete object constructor]
        nop
        ldp     x29, x30, [sp], 32
        ret
main:
        stp     x29, x30, [sp, -80]!
        mov     x29, sp
        add     x0, sp, 48
        bl      A::A() [complete object constructor]
        add     x0, sp, 48
        bl      std::remove_reference<A&>::type&& std::move<A&>(A&)
        mov     x1, x0
        add     x0, sp, 16
        bl      A::A(A&&) [complete object constructor]
        add     x0, sp, 16
        bl      A::~A() [complete object destructor]
        add     x0, sp, 48
        bl      A::~A() [complete object destructor]
        mov     w0, 0
        ldp     x29, x30, [sp], 80
        ret
vtable for A:
        .xword  0
        .xword  typeinfo for A
        .xword  A::~A() [complete object destructor]
        .xword  A::~A() [deleting destructor]
typeinfo for A:
        .xword  _ZTVN10__cxxabiv117__class_type_infoE+16
        .xword  typeinfo name for A
typeinfo name for A:
        .string "1A"
DW.ref.__gxx_personality_v0:
        .xword  __gxx_personality_v0

总结一下：当用户自定义移动构造函数，或移动赋值运算符，或拷贝构造函数，或拷贝赋值运算符，或析构函数时，编译器不会自动生成移动构造函数和移动赋值运算符，这时，只要通过default方式定义默认的移动构造函数和移动赋值运算符，编译器就会自动生成默认的移动构造函数和移动赋值运算符，就可以解决这个问题了。

swordmanwk
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ 默认移动构造函数
星河的博客
12-28 3541
class Test { public: Test(int v, const string& str) { p = new int(v); s = str; cout << "test()" << endl; } ~Test() { cout << "~Test()" << endl; delete p; p = nullptr;
c++ 默认移动构造函数什么时候会自动生成以及它内部实现
qq_41021141的博客
06-11 1709
而在没有自定义移动构造函数/移动赋值函数的情况下，如果该类自定义了拷贝构造函数/赋值运算符或析构函数之一，都不会生成默认移动构造函数，只会调用拷贝构造函数/赋值运算符（前提是形参为const T&而不是T&，因为const T&可以兼容右值实参，而T&不能）。注意即使没有自定义拷贝构造函数/赋值运算符，只自定义了析构函数，也不会生成默认移动构造函数，这是因为自定义析构函数表明该类在析构时可能需要回收内存，如果生成了默认移动构造函数可能会出错（比如同一地址被释放两次的错误）二、默认移动构造函数内部实现。
C++学习之路-编译器自动生成的构造函数
weixin_45452278的博客
08-03 1145
在该类中，我声明一个空的虚函数。创建对象时，也会调用构造函数。意味着，编译器也会默认的创建一个无参的构造函数public :} };我们通过查看构造函数内部，发现存在这样的一个操作：将虚表地址放在对象内存的最前面，用于查找虚表（细节可以查看我之前的博文）博文中：一旦类中有虚函数，创建对象时，对象最前面会多出四个字节存放虚表地址类中存在虚函数时，即使不写构造函数，编译器也会默认的生成一个无参的构造函数，从而在函数内部完成虚表地址的存放。......
C++中关于编译器自动生成的构造函数的探究
weixin_46715151的博客
04-09 581
C++中关于编译器自动生成的构造函数的探究以及相关总结
c++ 虚函数_C++ 合成默认构造函数的真相
weixin_39727743的博客
11-23 225
作者：melonstreet链接：https://www.cnblogs.com/QG-whz/p/4676481.html对于C++默认构造函数，我曾经有两点误解：类如果没有定义任何的构造函数，那么编译器(一定会!)将为类定义一个合成的默认构造函数。合成默认构造函数会初始化类中所有的数据成员。第一个误解来自于我学习C++的第一本书 《C++ Primer》，在书中392页：“只有当一...
MinGW-w64 C/C++编译器+libsvm安装包.rar
05-09
这个编译器套件包括了C、C++、Fortran等语言的编译器，支持多种编程语言的开发。MinGW-w64的主要优点是轻量级、无需安装Microsoft Visual Studio或其他大型IDE，且完全免费，适合于那些希望在Windows上进行原生C/C++...
MinGW-w64 C/C++ 编译器
08-08
MinGW-w64是GCC（GNU Compiler Collection）的一个分支，专为Windows平台设计，提供了针对32位和64位应用程序的C、C++以及其他语言的编译器。当你在MATLAB环境中尝试运行`mex -setup`命令来配置编译器时，如果出现...
Matlab安装MinGW-w64 C/C++ 编译器
04-01
在使用Matlab进行C或C++编程时，有时需要编译和链接外部代码，这就需要一个合适的C/C++编译器。MinGW-w64是一个轻量级的、开源的Windows上的GCC（GNU Compiler Collection）移植版，它为32位和64位的Windows系统提供...
编译器角度看C++复制构造函数
12-22
关于复制构造函数的简单介绍，可以看我以前写过的一篇文章Ｃ＋＋复制控制之复制构造函数该文章中介绍了复制构造函数的定义、调用时机、也对编译器合成的复制构造函数行为做了简单说明。本文因需要会涉及到上文的一些...
C++编译器会自动生成哪些函数
mandagod的博客
04-07 1252
C++编译器会自动生成哪些函数 构造函数拷贝构造函数析构函数赋值函数 如何不想要上面那些编译器自动生成的函数 比如我想实现单例模式 传统方法 将构造函数声明成private类型：为何声明成了private后就能实现单例模式呢 C++11做法 C++引入了两个指示符：delete和defaultdelete：告诉编译器不自动产生这个函数default
默认构造、拷贝、移动构造函数
willis
09-11 676
知识点 1.C++11编译器会默认生成以下的构造函数 //1.默认构造函数 //2.默认析构函数 //3.默认拷贝构造函数 //4.默认赋值函数 //5.移动构造函数 //6.移动拷贝函数 2.禁用构造函数用=delete Demo() = delete; //禁止生成默认构造函数 Demo(const Demo &) = delete; //禁止生成默认拷贝构造函数 Demo(Demo &...
C++11更新内容（2）--完美转发--默认移动构造/移动赋值--1116
qq_68741368的博客
11-17 1021
C++11相关的内容 未更新完全 下次内容会更新到该博文中
C++构造函数和编译器自动生成代码的陷阱
weixin_30244681的博客
08-27 111
最近在项目中debug各种access violation的，其中这个问题比较有代表性，并且能够被规范的代码标准解决。 问题可以总结为以下的代码： 1 class TestString 2 { 3 public: 4 TestString(const char* input) : m_value(input) {} 5 TestString(const T...
学习笔记：编译器自动生成的构造函数
huanhuaqian的博客
02-20 670
c++的编译器在某些特定的情况下，会给类自动生成无参的构造函数，比如 1. 成员变量再声明的同时进行了初始化 2. 有定义虚函数 3. 虚继承了其他类 4. 包含对象类型的成员，且这个成员有构造函数（编译器生成或自定义） 5. 父类有构造函数 总结： 对象创建后，需要做一些额外操作时（比如内存操作，函数调用），编译器一般都会为其生成构造函数。 demo: 不会自动生成构造函数 1. 无成员变量时，无需进行变量的初始化，在编译时没有必要生成构造函数。 class Person { };
C++会生成默认构造函数的四种情况
程序道 -Learning, Thinking and Coding <存储知识的金库>
03-27 612
C++标准是这样写的默认构造函数是由编译器在需要的时候将其合成出来，这里#include #include using namespace std; class A { public: char *ptr; //string str; }; int main() { A b; b.ptr=NULL; return 0; } 强调的是需要，而
深入了解默认构造、拷贝构造、移动构造函数
Z1042300201的专栏
06-15 3690
本文深入介绍默认构造，拷贝构造，移动构造的隐式声明、定义所需条件，分析其原因
C++ 2.0新特性——对象自动添加移动构造函数和移动赋值运算符
qq_33766994的博客
04-09 475
移动构造函数和移动赋值运算符 一、特种函数 特种函数：C++自行生成的成员函数。 C++98的4个特种成员函数：默认构造函数(无参)，析构函数、复制构造函数、复制赋值函数。 特种函数都具有public访问层级，都是inline，非虚的。只有在类中没有声明任何对应的函数，编译期才会自动生成。 class Widget { public: Widget();//默认构造函数 ~Widget(); //默认析构函数 Widget(const Widget& w); //默认复制构造函数 Wi
42.移动构造函数的合成规则
五山口老法师
10-18 680
不会使用移动造作： 当类的类成员定义了自己的拷贝构造函数且未定义移动构造函数 当类的类成员没有定义自己的拷贝构造函数且编译器不能为其合成移动构造函数 当有类的成员的移动构造函数或者移动赋值运算符是删除的或者不可访问的 当类的成员存在成员引用或者const的时候，移动赋值运算符被定义为删除的 如果一个类定义了自己的移动构造函数和/或移动赋值运算符,则该类的拷贝构造函数和拷贝赋值运算符被定义...
C++生成默认构造函数的条件
岳彦胜的专栏
06-08 1021
1. 有一个成员变量时类类型，而且该类有默认构造函数 2. 含有虚函数，需要初始化虚指针 3. 有虚基类，需要初始化虚指针 4. 基类有默认构造函数
yum install gcc gcc-c++ patch make glibc-static gcc-gfortran其中包含那些编译器
最新发布
12-13
根据提供的命令，可以看出其中包含以下编译器： - gcc：GNU Compiler Collection，是一套由GNU开发的编程语言编译器。 - gcc-c++：C++编译器，是gcc的一个子集，用于编译C++程序。 - patch：用于打补丁的工具。 - make：用于自动化编译的工具。 - glibc-static：GNU C库的静态版本，用于编译静态链接的程序。 - gcc-gfortran：Fortran编译器，是gcc的一个子集，用于编译Fortran程序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值