77 C++ 移动语义

C++11中的移动语义及其应用
最新推荐文章于 2025-12-05 21:43:14 发布
原创 最新推荐文章于 2025-12-05 21:43:14 发布 · 72 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言 #学习

文章讨论了C++11中的移动语义，指出在处理大量数据时，拷贝构造函数和赋值函数可能导致效率降低。移动语义通过转移而非拷贝资源来提高性能，主要涉及移动构造函数和移动赋值函数。文章提供了示例代码展示如何实现这些功能，并提到std::move()的作用以及在对象生命周期管理和容器中的应用。 
#include <iostream>
#include <cstring>
using namespace std;
// 移动语义
class AA
{
public:
    int *m_data = nullptr;
    AA() = default;
    void alloc()
    {
        m_data = new int;
        memset(m_data, 0, sizeof(int));
    }

    AA(const AA &a)
    {
        cout << "调用了拷贝构造函数" << endl;
        if (this == &a)
        {
            return;
        }
        if (m_data == nullptr)
        {
            alloc();
        }
        memcpy(m_data, a.m_data, sizeof(int)); //把数据从源对象中拷贝过来
    }
    AA &operator=(const AA &a)
    {
        cout << "调用了赋值函数" << endl;
        if (this == &a)
        {
            return *this;
        }
        if (m_data == nullptr)
        {
            alloc();
        }
        memcpy(m_data, a.m_data, sizeof(int));
        return *this;
    }
    ~AA()
    {
        cout << "调用了析构函数" << endl;
        if (m_data != nullptr)
        {
            delete m_data;
            m_data = nullptr;
        }
    }
};
void test()
{
    AA a1;
    a1.alloc();
    *a1.m_data = 3;
    cout << "a1.m_data=" << *a1.m_data << endl;

    AA a2 = a1;
    cout << "a2.m_data=" << *a2.m_data << endl;

    AA a3;
    a3 = a1;
    cout << "a3.m_data=" << *a3.m_data << endl;
}
int main()
{
    test();
    return 0;
}
/* a1.m_data=3
调用了拷贝构造函数
a2.m_data=3
调用了赋值函数
a3.m_data=3
调用了析构函数
调用了析构函数
调用了析构函数 */

上面代码，看看拷贝构造和赋值函数代码，每次调用这两个函数的时候，不一定要重新分配资源，但是一定会拷贝数据，如果数据量比较大，拷贝数据也要消耗时间，在C++11中，把拷贝数据的操作叫拷贝语义，而移动语义的意思是：不要拷贝，直接把资源转移过来，资源都是用指针指向的，把指针处理一下就可以转移资源，不拷贝数据。所以转移资源的操作叫做移动语义。

要实现移动语义，类必须提供移动构造函数和移动赋值函数。

#include <iostream>
#include <cstring>
using namespace std;
// 移动语义
class AA
{
public:
    int *m_data = nullptr;
    AA() = default;
    void alloc()
    {
        m_data = new int;
        memset(m_data, 0, sizeof(int));
    }

    AA(const AA &a)
    {
        cout << "调用了拷贝构造函数" << endl;
        if (this == &a)
        {
            return;
        }
        if (m_data == nullptr)
        {
            alloc();
        }
        memcpy(m_data, a.m_data, sizeof(int)); //把数据从源对象中拷贝过来
    }
    //移动构造函数
    AA(AA &&a) //因为需要操作被转移对象中的指针,所以不能用const
    {
        cout << "调用了移动构造函数" << endl;
        if (m_data != nullptr)
        {
            delete m_data; //如果已经分配内存,先释放掉
        }
        m_data = a.m_data;  //把资源从源对象中转移过来
        a.m_data = nullptr; //把源对象中的指针置空
    }
    AA &operator=(const AA &a)
    {
        cout << "调用了赋值函数" << endl;
        if (this == &a)
        {
            return *this;
        }
        if (m_data == nullptr)
        {
            alloc();
        }
        memcpy(m_data, a.m_data, sizeof(int));
        return *this;
    }

    //移动赋值函数
    AA &operator=(AA &&a)
    {
        cout << "调用了移动赋值函数" << endl;
        if (this == &a)
        {
            return *this;
        }
        if (m_data != nullptr)
        {
            delete m_data;
        }
        m_data = a.m_data;
        a.m_data = nullptr;
        return *this;
    }
    ~AA()
    {
        cout << "调用了析构函数" << endl;
        if (m_data != nullptr)
        {
            delete m_data;
            m_data = nullptr;
        }
    }
};
AA func()
{
    AA a;
    a.alloc();
    *a.m_data = 19;
    return a;
}
void test()
{
    /* AA a1;
    a1.alloc();
    *a1.m_data = 3;
    cout << "a1.m_data=" << *a1.m_data << endl;

    AA a2 = a1;
    cout << "a2.m_data=" << *a2.m_data << endl;

    AA a3;
    a3 = a1;
    cout << "a3.m_data=" << *a3.m_data << endl;

    cout << "------------------------------" << endl; */

    auto getTemp = []
    {
        AA a;
        a.alloc();
        *a.m_data = 10;
        return a;
    };
    AA a4 = getTemp(); // VS里面会显示调用移动构造函数,G++是不是做了优化,没有调用移动构造函数
    *a4.m_data = 1;
    cout << "a4.m_data=" << *a4.m_data << endl;

    AA a6 = func(); // VS里面会显示调用移动构造函数,G++是不是做了优化,没有调用移动构造函数
    cout << "a6.m_data=" << *a6.m_data << endl;

    AA a5;
    a5 = getTemp();
    cout << "a5.m_data=" << *a5.m_data << endl;
}
int main()
{
    test();
    return 0;
}
a4.m_data=1
a6.m_data=19
调用了移动赋值函数
调用了析构函数
a5.m_data=10
调用了析构函数
调用了析构函数
调用了析构函数

VS里面会显示调用移动构造函数,G++是不是做了优化,没有调用移动构造函数

如果一个对象中有堆区资源，需要编写拷贝构造函数和赋值函数，实现深拷贝。

深拷贝把对象中的堆区资源复制了一份，如果源对象（被拷贝的对象）是临时对象，拷贝完就没什么用了，这样会造成没有意义的资源申请和释放操作。如果能够直接使用源对象拥有的资源，可以节省资源申请和释放的时间。C++11新增加的移动语义就能够做到这一点。

实现移动语义要增加两个函数：移动构造函数和移动赋值函数。

移动构造函数的语法：

类名(类名&& 源对象){......}

移动赋值函数的语法：

类名& operator=(类名&& 源对象){……}

注意：

1）对于一个左值，会调用拷贝构造函数，但是有些左值是局部变量，生命周期也很短，能不能也移动而不是拷贝呢？C++11为了解决这个问题，提供了std::move()方法来将左值转义为右值，从而方便使用移动语义。它其实就是告诉编译器，虽然我是一个左值，但不要对我用拷贝构造函数，用移动构造函数吧。左值对象被转移资源后，不会立刻析构，只有在离开自己的作用域的时候才会析构，如果继续使用左值中的资源，可能会发生意想不到的错误。

2）如果没有提供移动构造/赋值函数，只提供了拷贝构造/赋值函数，编译器找不到移动构造/赋值函数就去寻找拷贝构造/赋值函数。

3）C++11中的所有容器都实现了移动语义，避免对含有资源的对象发生无谓的拷贝。

4）移动语义对于拥有资源（如内存、文件句柄、网络连接）的对象有效，如果是基本类型，使用移动语义没有意义。

#include <iostream>
#include <cstring>
using namespace std;
// 移动语义
class AA
{
public:
    int *m_data = nullptr;
    AA() = default;
    void alloc()
    {
        m_data = new int;
        memset(m_data, 0, sizeof(int));
    }

    AA(const AA &a)
    {
        cout << "调用了拷贝构造函数" << endl;
        if (this == &a)
        {
            return;
        }
        if (m_data == nullptr)
        {
            alloc();
        }
        memcpy(m_data, a.m_data, sizeof(int)); //把数据从源对象中拷贝过来
    }
    //移动构造函数
    AA(AA &&a) //因为需要操作被转移对象中的指针,所以不能用const
    {
        cout << "调用了移动构造函数" << endl;
        if (m_data != nullptr)
        {
            delete m_data; //如果已经分配内存,先释放掉
        }
        m_data = a.m_data;  //把资源从源对象中转移过来
        a.m_data = nullptr; //把源对象中的指针置空
    }
    AA &operator=(const AA &a)
    {
        cout << "调用了赋值函数" << endl;
        if (this == &a)
        {
            return *this;
        }
        if (m_data == nullptr)
        {
            alloc();
        }
        memcpy(m_data, a.m_data, sizeof(int));
        return *this;
    }

    //移动赋值函数
    AA &operator=(AA &&a)
    {
        cout << "调用了移动赋值函数" << endl;
        if (this == &a)
        {
            return *this;
        }
        if (m_data != nullptr)
        {
            delete m_data;
        }
        m_data = a.m_data;
        a.m_data = nullptr;
        return *this;
    }
    ~AA()
    {
        cout << "调用了析构函数" << endl;
        if (m_data != nullptr)
        {
            delete m_data;
            m_data = nullptr;
        }
    }
};
AA func()
{
    AA a;
    a.alloc();
    *a.m_data = 19;
    return a;
}
void test()
{
    AA a1;
    a1.alloc();
    *a1.m_data = 3;
    cout << "a1.m_data=" << *a1.m_data << endl;

    AA a2 = a1;
    cout << "a2.m_data=" << *a2.m_data << endl;

    AA a3;
    a3 = move(a1); //调用了移动赋值函数 但是注意不能move多次,且move后,后面使用就要注意空指针了
    // a3 = a1;       //调用了赋值函数
    cout << "a3.m_data=" << *a3.m_data << endl;
}
int main()
{
    test();
    return 0;
}
/* a1.m_data=3
调用了拷贝构造函数
a2.m_data=3
调用了移动赋值函数
a3.m_data=3
调用了析构函数
调用了析构函数
调用了析构函数 */

C++ 移动语义解析
ComputerInBook的专栏
06-20 777
C++ 右值引用
C++移动语义详解
weixin_44049823的博客
08-25 1197
摘要：C++11引入的移动语义通过转移资源所有权而非复制资源，显著提升程序性能，尤其适用于处理大型对象。其核心在于区分左值和右值，利用右值引用实现资源转移。移动构造函数和移动赋值运算符负责从临时对象中"窃取"资源，而std::move可将左值强制转换为右值引用以启用移动语义。该特性避免了冗余拷贝，确保资源安全，是现代C++高效资源管理的关键机制。（150字）
C++移动语义完全理解
谢白羽
07-20 1241
文章目录1.对象移动的概念1）产生原因：2）作用： 1.对象移动的概念 1）产生原因： 临时对象的产生肯定要面临大量数据的复制，例如把数据复制给临时对象，然后又把数据从临时对象复制出来等。这种复制显然会极大地影响程序运行效率，所以C++11会引入对象移动这个概念 2）作用： 把临时对象中有用的数据如new出来的一块内存接管过来，那么创建该类新对象就不用再new一块新内存。所有权转移之后，销毁临时对象时，已经转移出去的数据当然就不需要随之一起销毁了 ...
C++移动语义move
chenmi123321的博客
12-08 1015
1移动语义的核心是利用右值引用（T&&）和标准库中的std::move，使对象的资源从一个对象转移到另一个对象，而不是拷贝，从而提高程序性能。减少临时对象的开销（如函数返回大对象）。避免深拷贝（如容器中的数据转移）。使用右值引用（T&&）定义移动构造函数和移动赋值运算符。移动语义可以避免冗余的深拷贝操作，提高程序效率。使用std::move显式启用移动语义。
C++ 移动语义
2201_75663820的博客
10-25 1187
本文主要讲述了C++11引入的移动语义和完美转发 ...
C++ 移动语义与完美转发详解
嗨，欢迎来到我的 优快云 博客小天地！一名深耕多年的技术发烧友。在这里，我将把日常工作中积累的宝贵经验，从复杂架构设计的精妙之处，到代码优化的实战技巧，毫无保留地分享给大家。
07-21 1508
C++ 移动语义与完美转发详解
C++移动语义
2302_81041084的博客
11-21 886
当函数返回一个局部对象时，在没有移动语义的情况下，可能会进行一次拷贝操作来返回这个对象。而有了移动语义，编译器可以优化这个过程，直接将局部对象的资源转移给函数的返回值，避免了不必要的复制。对于资源密集型对象，如文件流对象，移动语义允许高效地转移文件句柄的所有权，而不是重新打开文件并复制相关的缓冲区等资源。对象作为参数传递给一个函数，并且在函数内部不需要保留原始对象的内容，那么使用移动语义可以避免复制整个字符数组。）处于一种有效但未定义的状态，通常它的资源已经被转移，再次使用这个对象时需要谨慎。
C++中的移动语义
qq2745567641的博客
06-02 733
摘要：移动语义是C++11引入的核心特性，通过右值引用和移动构造函数实现资源所有权转移而非复制，显著提升性能。关键点包括：右值引用绑定临时对象，std::move强制转换右值，移动操作避免深拷贝（时间复杂度从O(n)降为O(1)），以及noexcept优化容器操作。典型应用场景包括临时对象传递、容器优化和资源管理类。需注意避免悬空引用和过度使用std::move。移动语义配合完美转发（std::forward）构成了现代C++高效资源管理的基础。
C++: 移动语义
qq_54375651的博客
05-24 840
移动构造函数是一种特殊的构造函数，它用于创建一个新对象，并将一个已存在的对象的所有资源转移到新对象上。移动语义是 C++11 引入的一种新特性，移动的意思是转移所有权，它允许资源的所有权从一个对象转移到另一个对象，而不需要进行昂贵的拷贝操作。由于右值都是临时的值，临时值释放后也就不再持有属性的所有权，因此右值引用相当于转移资源所有权的行为。lambda表达式可以创建一个匿名函数对象，是右值，可以作为参数传递给其他函数。：表达式结束后就不再存在的临时对象，不可取地址。引入了一种新的引用类型，称为。
C++移动语义概述
Hugh的博客
06-05 360
C++ 移动语义与完美转发速览
[C++]string类的使用和模拟实现
我的博客
12-01 878
本文系统介绍了C++中string类的使用与实现方法。首先分析了string类的函数风格，包括参数传递方式、const与非const迭代器区别及隐式类型转换特性。然后详细讲解了string类的核心实现，包括构造函数、析构函数、拷贝构造等基础功能，以及迭代器、容量操作等内联函数实现。重点剖析了字符串的增删查改操作，如扩容机制、插入删除算法等实现细节，并指出了常见错误点（如'\0'处理、size_t循环问题）。通过具体代码示例展示了operator>>、insert等关键函数的实现逻辑，帮助读者掌握
【C++完结篇】：深入“次要”但关键的知识腹地
我们无法预测机会什么时候降临，所以我们能做的只有努力！
12-04 983
本文总结了C++的扩展内容，主要包括类型转换、IO流、反向迭代器实现和计算器实现四个部分。static_cast、reinterpret_cast、const_cast、dynamic_cast，RTTI机制。IO流部分介绍了标准IO流家族、流状态标识、缓冲区机制和文件IO流操作，重点讲解了二进制读写注意事项。反向迭代器部分分析了STL实现原理并给出了简化版实现。
C语言 函数
cja0222的博客
12-01 920
在C语言的世界里，函数不仅是代码组织的基本单元，更是程序员构建复杂系统的思维工具。从简单的 main()函数到庞大的库函数集合，函数贯穿了C语言的每个角落。重要的是自定义函数。自定义函数和库函数一样，有函数名，返回值类型和函数参数。所谓自定义就是这些都是我们自己来设计。这给我们自己一个很大的发挥空间。ret_type fun_name(形式参数)//ret_type是函数返回类型//fun_name是函数名// ()括号中放的是形式参数//{}括起来的是函数体。
LinuxC语言并发程序笔记补充
chenzhou__的博客
12-04 490
锁除了互斥锁，还有一个读写锁，进程通信还有对互斥锁优化的条件变量和死锁的概念。
C++ 设计模式之单例模式详细介绍
XiaoBinbest的博客
12-01 1316
唯一性：类的实例在整个程序中只能有一个，禁止外部通过new、拷贝等方式创建多个实例。全局访问：提供一个静态方法（如），让程序任何地方都能便捷访问该实例。可控初始化：根据需求选择“提前初始化”（饿汉式）或“延迟初始化”（懒汉式），平衡资源占用与启动速度。实现方式线程安全（C++11+）延迟初始化代码复杂度内存泄漏风险推荐优先级Meyers 单例（局部静态）是是极低无★★★★★饿汉式（全局静态）是否低无★★★★☆懒汉式（互斥锁）是是中有（需手动销毁）
华为OD机试双机位C卷 - 数组连续和 (C++ & Python & JAVA & JS & GO)
qq_45776114的博客
12-03 547
华为OD机试双机位C卷 数组连续和，提供Java、C++、Python、Go、JavaScript源码实现，并提供完整思路讲解。
单片机 使用 cJson 添加 无符号 32 位数值（uint32_t）溢出问题的解决办法
weixin_46158019的博客
12-05 212
的最大值（2147483647）时，数据不正常。，使用的是 ARMCC 系统工具链 ，文件。单片机 使用在 cJSON 中添加无符号32位（）数据出现「溢出」。）数据 ，超过 有符号32位(，查看此函数 调用关系 —>cJson 使用的函数是。
C 语言项目实践：用指针实现一个“班级成绩智能分析器”
最新发布
m0_74456227的博客
12-05 639
摘要 本文通过一个班级成绩分析工具实例，生动演示了C语言指针的实际应用。文章展示了如何使用指针动态分配内存存储成绩数据，遍历数组计算平均分、最高/最低分，通过指针排序实现成绩排名，并检测不及格学生。每个功能模块都配有详细代码解析和示例测试结果，帮助读者理解指针的核心概念和常见错误（如错误赋值整数给指针）。该案例将抽象的指针概念融入实际编程场景，既讲解原理又提供实用代码示例。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值