C++ C11 移动语义和右值引用

已于 2024-08-29 21:20:02 修改
阅读量1k 收藏 30
点赞数 27
文章标签： c++ 开发语言
于 2024-08-27 21:33:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/waltWu0705/article/details/141612663
版权

1.背景

浅拷贝重复释放
默认构造函数是浅拷贝。 
class A
{
public:
A() :m_ptr(new int(0)) {//浅拷贝
cout << "constructor A" << endl;
}
~A(){
delete m_ptr;
m_ptr = nullptr;
}
private:
int* m_ptr;
};
深拷贝构造函数
对于含有堆内存的类，我们需要提供深拷贝的拷贝构造函数，如果使用默认构造函数，会导致堆内存的重复删除。 
class A
{
public:
A() :m_ptr(new int(0)) {
cout << "constructor A" << endl;
}
A(const A& a) :m_ptr(new int(*a.m_ptr)) {
cout << "copy constructor A" << endl;
}
~A(){
cout << "destructor A, m_ptr:" << m_ptr << endl;
delete m_ptr;
m_ptr = nullptr;

private:
int* m_ptr;
};

但上面的深拷贝可行，但在如果堆内存很大，那么，这个拷贝构造的代价会很大，

带来了额外的性能损耗。所以，移动构造函数出现了。 
class A
{
public:
A() :m_ptr(new int(0)) {
cout << "constructor A" << endl;
}

A(A&& a) :m_ptr(a.m_ptr) {//移动构造
a.m_ptr = nullptr; // 为防止a析构时delete data，提前置空其m_ptr
cout << "move constructor A" << endl;
}

~A(){
cout << "destructor A, m_ptr:" << m_ptr << endl;
delete m_ptr;
m_ptr = nullptr;

private:
int* m_ptr;
};
这里 没有深拷贝，只有浅拷贝 ，这样就避免了对临时对象的深拷贝，提高了性能。

2.相关困惑

2.1 移动语义

移动语义可以将资源（堆、系统对象等）通过浅拷贝方式从一个对象转移到另一个对象，这样能够减少 不必要的临时对象的创建、拷贝以及销毁，可以大幅度提高 C++ 应用程序的性能，消除临时对象的维护 (创建和销毁）对性能的影响。

2.2 右值引用

右值引用的一个重 要目的是用来支持移动语义的.

2.3 std::move

std::move 只是一个类型转换工具，将其参数转换为右值引用，以启用移动语义.

std::move 是一个类型转换工具，它将其参数转换为右值引用，从而启用移动语义。它本身并不执行任何移动操作，只是告诉编译器这个对象可以移动。

#include <iostream>
#include <vector>

void process(MyClass obj) {
    // 处理对象
}

int main() {
    MyClass obj1(10);
    process(std::move(obj1)); // 使用 std::move 将 obj1 转换为右值引用，启用移动语义

    return 0;
}

在这个示例中，std::move 将 obj1 转换为右值引用，从而调用 process 函数时，启用移动构造函数，而不是拷贝构造函数。

2.4 即使类中不涉及动态数据管理，使用 std::move 仍然能够提高效率.

特别是对于大对象,如3.1 函数返回值优化。

如果类的成员支持移动操作且没有显式定义移动构造函数和移动赋值运算符，编译器会自动生成默认的移动构造函数和移动赋值运算符.这些默认的构造函数虽然没有涉及动态数据。但数据的管理者从一个对象转移到另一个对象了。

2.4.1 拷贝操作 vs 移动操作

拷贝操作

在拷贝操作中，资源所有权并没有转移，而是通过复制来共享资源。这意味着原对象和新对象都各自管理一份独立的资源。

#include <iostream>
#include <vector>

class MyClass {
public:
    MyClass(int size) : data(new int[size]), size(size) {
        std::cout << "Constructor" << std::endl;
    }

    // 拷贝构造函数
    MyClass(const MyClass& other) : data(new int[other.size]), size(other.size) {
        std::copy(other.data, other.data + size, data);
        std::cout << "Copy constructor" << std::endl;
    }

    ~MyClass() {
        delete[] data;
        std::cout << "Destructor" << std::endl;
    }

private:
    int* data;
    int size;
};

int main() {
    MyClass obj1(10);
    MyClass obj2 = obj1; // 调用拷贝构造函数，obj1 和 obj2 各自管理一份资源

    return 0;
}

在这个示例中，拷贝构造函数创建了 obj1 的一个副本，obj1 和 obj2 各自管理一份独立的内存资源。

移动操作

在移动操作中，资源所有权从一个对象转移到另一个对象，原对象不再管理该资源。这意味着移动操作不会创建资源的副本，而是简单地将资源的指针或句柄转移到新对象。

#include <iostream>
#include <vector>

class MyClass {
public:
    MyClass(int size) : data(new int[size]), size(size) {
        std::cout << "Constructor" << std::endl;
    }

    // 移动构造函数
    MyClass(MyClass&& other) noexcept : data(other.data), size(other.size) {
        other.data = nullptr;
        other.size = 0;
        std::cout << "Move constructor" << std::endl;
    }

    ~MyClass() {
        delete[] data;
        std::cout << "Destructor" << std::endl;
    }

private:
    int* data;
    int size;
};

int main() {
    MyClass obj1(10);
    MyClass obj2 = std::move(obj1); // 调用移动构造函数，obj1 的资源所有权转移给 obj2

    return 0;
}

在这个示例中，移动构造函数将 obj1 的资源所有权转移给 obj2，并将 obj1 的指针设为 nullptr，表示 obj1 不再管理该资源。

3.应用

3.1 函数返回值优化

当函数返回一个大对象时，使用 std::move 可以避免拷贝操作，将对象的所有权转移给调用者。

#include <iostream>
#include <vector>

class LargeObject {
public:
    LargeObject() : data(1000000, 0) {
        std::cout << "Constructor" << std::endl;
    }
    
    LargeObject(const LargeObject& other) : data(other.data) {
        std::cout << "Copy constructor" << std::endl;
    }

    LargeObject(LargeObject&& other) noexcept : data(std::move(other.data)) {
        std::cout << "Move constructor" << std::endl;
    }

private:
    std::vector<int> data;
};

LargeObject createLargeObject() {
    LargeObject obj;
    return std::move(obj); // 将对象的所有权转移给返回值
}

int main() {
    LargeObject obj = createLargeObject(); // 避免拷贝操作
    return 0;
}

在这个示例中，std::move 将 obj 转换为右值引用，调用移动构造函数，而不是拷贝构造函数，避免了拷贝大对象的开销。

3.2 函数调用传递临时对象

#include <iostream>
#include <vector>

void process(std::vector<int> vec) {
    std::cout << "Processing vector of size: " << vec.size() << std::endl;
}

int main() {
    std::vector<int> vec(100, 1);
    process(std::move(vec)); // 使用 std::move 将临时对象传递给函数

    return 0;
}

在这个示例中，std::move 将 vec 转换为右值引用，从而调用 process 函数时，避免了拷贝操作

3.3 容器的元素移动

在 STL 容器中，使用 std::move 可以高效地插入或转移元素，而不是进行昂贵的拷贝操作

#include <iostream>
#include <vector>

class MyClass {
public:
    MyClass() {
        std::cout << "Default constructor" << std::endl;
    }

    MyClass(const MyClass& other) {
        std::cout << "Copy constructor" << std::endl;
    }

    MyClass(MyClass&& other) noexcept {
        std::cout << "Move constructor" << std::endl;
    }
};

int main() {
    std::vector<MyClass> vec;
    MyClass obj;

    vec.push_back(std::move(obj)); // 使用 std::move 将对象的所有权转移到容器中

    return 0;
}

在这个示例中，std::move 将 obj 转换为右值引用，从而调用 MyClass 的移动构造函数，而不是拷贝构造函数，避免了不必要的拷贝操作。

3.4 标准库函数中的应用

许多标准库函数也使用 std::move 来实现高效的元素转移。

3.4.1 emplace_back 减少内存拷贝和移动

c++11 可以用 emplace_back 代替 push_back ， emplace_back 可以直接在 vector 中构建一个对象，而非 创建一个临时对象，再放进vector ，再销毁。 emplace_back 可以省略一次构建和一次析构，从而达到优 化的目的。

3.4.2 std::swap 使用 std::move 来交换两个对象的内容。

#include <iostream>
#include <utility>

int main() {
    std::string str1 = "Hello";
    std::string str2 = "World";

    std::swap(str1, str2); // 使用 std::move 在 std::swap 中实现高效交换

    std::cout << "str1: " << str1 << std::endl; // 输出 "World"
    std::cout << "str2: " << str2 << std::endl; // 输出 "Hello"

    return 0;
}

std::swap 内部使用 std::move 来实现高效的元素交换，避免不必要的拷贝操作。

3.5 自定义类的移动赋值运算符

在自定义类中，使用 std::move 可以实现高效的移动赋值运算符

#include <iostream>
#include <string>

class MyClass {
public:
    MyClass(std::string name) : name(std::move(name)) {
        std::cout << "Constructor" << std::endl;
    }

    MyClass(MyClass&& other) noexcept : name(std::move(other.name)) {
        std::cout << "Move constructor" << std::endl;
    }

    MyClass& operator=(MyClass&& other) noexcept {
        if (this != &other) {
            name = std::move(other.name);
            std::cout << "Move assignment operator" << std::endl;
        }
        return *this;
    }

private:
    std::string name;
};

int main() {
    MyClass obj1("Object 1");
    MyClass obj2("Object 2");

    obj2 = std::move(obj1); // 使用移动赋值运算符

    return 0;
}

3.5.1 如果没有自定义的移动赋值运算符

#include <iostream>
#include <string>

class MyClass {
public:
    MyClass(std::string name) : name(std::move(name)) {
        std::cout << "Constructor" << std::endl;
    }

    MyClass(MyClass&& other) noexcept : name(std::move(other.name)) {
        std::cout << "Move constructor" << std::endl;
    }

    // 移除自定义的移动赋值运算符
    // MyClass& operator=(MyClass&& other) noexcept {
    //     if (this != &other) {
    //         name = std::move(other.name);
    //         std::cout << "Move assignment operator" << std::endl;
    //     }
    //     return *this;
    // }

private:
    std::string name;
};

int main() {
    MyClass obj1("Object 1");
    MyClass obj2("Object 2");

    obj2 = std::move(obj1); // 使用默认的移动赋值运算符

    return 0;
}
3.5.1.1 默认移动赋值运算符的行为

在没有自定义移动赋值运算符的情况下，编译器会自动生成一个默认的移动赋值运算符。这个默认的移动赋值运算符的行为是：

1. 将每个非静态成员从右值对象移动到当前对象。

2. 返回当前对象的引用。

对于 std::string 这样的标准库类型，默认的移动赋值运算符会调用 std::string 自己的移动赋值运算符，这样就能有效地移动字符串的内容。

3.5.1.2 区别和潜在问题
1）. 行为一致：

在这个特定示例中，默认的移动赋值运算符的行为与自定义的移动赋值运算符基本一致，因为它会调用 std::string 的移动赋值运算符，将字符串的内容从 other 移动到当前对象。因此，不会有显著的性能差异。

2）. 默认生成条件：

默认的移动赋值运算符仅在类的所有成员都可以移动时才会生成。如果类中有某些成员不支持移动操作（如显式删除了移动构造函数或移动赋值运算符），编译器将不会生成默认的移动赋值运算符。

情况 1：所有成员都支持移动操作
#include <iostream>
#include <string>

class Movable {
public:
    Movable() = default;
    Movable(const Movable&) = default;
    Movable(Movable&&) noexcept = default; // 支持移动构造
    Movable& operator=(const Movable&) = default;
    Movable& operator=(Movable&&) noexcept = default; // 支持移动赋值
};

class MyClass {
public:
    Movable movableMember; // 支持移动操作的成员
    std::string str;       // 支持移动操作的成员
};

int main() {
    MyClass obj1;
    MyClass obj2;

    obj2 = std::move(obj1); // 调用默认的移动赋值运算符

    std::cout << "Move assignment operator called successfully." << std::endl;
    return 0;
}

在这个示例中，MyClass 的所有成员都支持移动操作，因此编译器会自动生成一个默认的移动赋值运算符，并且 obj2 = std::move(obj1) 语句将会成功执行。

情况 2：某些成员不支持移动操作
#include <iostream>
#include <string>

class NonMovable {
public:
    NonMovable() = default;
    NonMovable(const NonMovable&) = default;
    NonMovable(NonMovable&&) noexcept = delete; // 禁止移动构造
    NonMovable& operator=(const NonMovable&) = default;
    NonMovable& operator=(NonMovable&&) noexcept = delete; // 禁止移动赋值
};

class MyClass {
public:
    NonMovable nonMovableMember; // 不支持移动操作的成员
    std::string str;             // 支持移动操作的成员
};

int main() {
    MyClass obj1;
    MyClass obj2;

    // obj2 = std::move(obj1); // 编译错误：默认的移动赋值运算符不会生成

    std::cout << "Move assignment operator not generated." << std::endl;
    return 0;
}

在这个示例中，MyClass 包含一个 NonMovable 成员，而 NonMovable 显式删除了移动构造函数和移动赋值运算符。因此，编译器不会为 MyClass 生成默认的移动赋值运算符。如果尝试执行 obj2 = std::move(obj1)，将会导致编译错误，因为 MyClass 没有移动赋值运算符。

解决方法

如果类的某些成员不支持移动操作，但你仍然需要移动赋值运算符，可以显式定义自己的移动赋值运算符。

显式定义移动赋值运算符

#include <iostream>
#include <string>

class NonMovable {
public:
    NonMovable() = default;
    NonMovable(const NonMovable&) = default;
    NonMovable(NonMovable&&) noexcept = delete; // 禁止移动构造
    NonMovable& operator=(const NonMovable&) = default;
    NonMovable& operator=(NonMovable&&) noexcept = delete; // 禁止移动赋值
};

class MyClass {
public:
    NonMovable nonMovableMember; // 不支持移动操作的成员
    std::string str;             // 支持移动操作的成员

    MyClass& operator=(MyClass&& other) noexcept {
        if (this != &other) {
            // 非移动成员使用拷贝赋值
            nonMovableMember = other.nonMovableMember;
            // 移动成员使用移动赋值
            str = std::move(other.str);
        }
        return *this;
    }
};

int main() {
    MyClass obj1;
    MyClass obj2;

    obj2 = std::move(obj1); // 调用显式定义的移动赋值运算符

    std::cout << "Custom move assignment operator called successfully." << std::endl;
    return 0;
}

在这个示例中，我们显式定义了 MyClass 的移动赋值运算符。在这个运算符中，我们对不支持移动的成员使用拷贝赋值，对支持移动的成员使用移动赋值，从而实现了对 MyClass 对象的移动赋值操作。

3.） 自定义逻辑：

如果需要在移动操作中执行特定的逻辑（如资源管理、日志记录等），则必须自定义移动赋值运算符。默认的移动赋值运算符不会执行这些自定义逻辑。

3.5.2 需要自定义移动赋值运算符

以下是一个需要自定义移动赋值运算符的示例，展示了默认移动赋值运算符无法满足需求的情况：

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass(int size) : data(new int[size]), size(size) {
        std::cout << "Constructor" << std::endl;
    }

    MyClass(MyClass&& other) noexcept : data(other.data), size(other.size) {
        other.data = nullptr;
        other.size = 0;
        std::cout << "Move constructor" << std::endl;
    }

    MyClass& operator=(MyClass&& other) noexcept {
        if (this != &other) {
            delete[] data; // 释放当前对象的资源
            data = other.data;
            size = other.size;
            other.data = nullptr;
            other.size = 0;
            std::cout << "Move assignment operator" << std::endl;
        }
        return *this;
    }

    ~MyClass() {
        delete[] data;
        std::cout << "Destructor" << std::endl;
    }

private:
    int* data;
    int size;
};

int main() {
    MyClass obj1(10);
    MyClass obj2(20);

    obj2 = std::move(obj1); // 使用自定义的移动赋值运算符

    return 0;
}

在这个示例中，MyClass 管理动态分配的内存资源。如果没有自定义移动赋值运算符，默认的移动赋值运算符不会释放当前对象的资源，可能导致内存泄漏。因此，必须自定义移动赋值运算符以正确管理资源。

waltWu0705
关注
C++11中value category（值类别）及move semantics（移动语义）的介绍
08-27
C++11引入了value category（值类别）和move semantics（移动语义）的概念，以增强语言的效率和性能。值类别是对表达式在程序执行过程中所处状态的分类，而移动语义则是一种优化机制，它允许资源的有效转移，避免...
C++11---右值引用(深度讲解)
2303_78660611的博客
03-31 2377
左值是一个数据的表达式(例如变量或者解引用后的指针),我们可以对其进行取地址和修改赋值,左值可以出现在赋值符号的左边,而右值不能出现在赋值符号的左边,而左值引用就是对左值起别名,如图1. 左值引用只能引用左值，不能引用右值。2. 但是const左值引用既可引用左值，也可引用右值1. 右值引用只能右值，不能引用左值。2. 但是右值引用可以move以后的左值。
【C++11】浅谈右值引用
szy0321的博客
03-29 484
右值引用 什么是左值和右值：左值实指表达式结束后依然存在的持久对象，右值是指表达式结束后就不存在的临时对象。 区分左值和右值的便捷方法：看能不能对表达式取地址，如果能，为左值，如果不能，则为右值。所有的具名变量或对象都是左值，而右值不具名。 在C++11中右值由两个概念构成： 1.一个是纯右值，比如，非引用返回的临时变量，运算表达式产生的临时变量，原始字面量和la’mbda表达式等都是纯右值。 2.另一个则是将亡值，而将亡值是C++11新增的与右值引用相关的表达式，比如将要被移动的对象、T&&amp
c11右值与移动语义
donghb1991的博客
07-12 593
左值和右值：## 标题 左值具名，对应指定内存域，可访问；右值不具名，不对应内存域，不可访问； 临时对像是右值，左值可处于等号左边，右值只能放在等号右边，区分表达式的左右值属性有一个简便方法：若可对表达式用 & 符取址，则为左值，否则为右值。 右值引用：## 标题 在 C++11 之前，右值是不能被引用的，最大限度就是用常量引用绑定一个右值，如 :const int &a = 1; 在这种情况下，右值不能被修改的。但是实际上右值是可以被修改的，既然右值可以被修改，那么就可以实现右值引用。C1
c11标准-----》右值引用
weixin_46566893的博客
05-29 406
下册册从
C11新特性二 —— 右值引用
weixin_43662553的博客
05-19 407
C11新特性二 —— 右值引用
C11 C++11标准帮助文档中文版-20181230
03-22
2. 右值引用：引入右值引用，为移动语义和完美转发提供了基础，显著提升了资源管理的效率。 3. Lambda表达式：允许在代码中定义匿名函数，简化了回调函数和函数对象的使用。 4. 移动构造函数和移动赋值运算符：优化...
c++文档（包含c11汉化版本和英文版本）
02-25
2. **右值引用（Rvalue References）**：右值引用允许开发者更好地处理临时对象，是实现移动语义的基础，有助于提高性能，特别是在对象拷贝时。 3. **Lambda表达式**：C++11引入了lambda函数，使得在代码中创建匿名...
c++99和c++11规范原版pdf
09-27
1. **右值引用（Rvalue References）**：右值引用允许开发者区分左值和右值，使得移动语义成为可能，这极大地优化了资源的分配和回收，比如在std::move函数中的应用。 2. **类型推断（Type Inference）与auto关键字...
C++_C11.rar
01-14
首先，C++11在语法层面引入了右值引用（Rvalue References），这是一项关键的改进，用于支持更好的资源管理，特别是通过移动语义（Move Semantics）实现。移动语义允许对象的状态在构造函数和析构函数之间有效地转移...
C11-右值引用std::move移动语义和完美转发用法举例
MorningStar的博客
06-04 554
SHOW_SMALL_FUNCTION_BLOCK_TIPS("右值引用") /* 这个是个小的Demo */ { class Test { public: Test() = default; int a; Test(Test&& temp)noexcept { cout << "执行移动构造函数" << endl;; cout << "执行ByeBye(temp);" <&lt.
C++11(右值引用、移动构造、移动赋值、lambda表达式）
Adenson的博客
04-30 775
1、列表初始化（了解其用法） 2、范围for循环 3、final 与 override final:定义最终类或修饰虚函数，是该类和虚函数不能被继承 override：检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。 注意区分：如果基类定义纯虚函数，则子类必须重写纯虚函数。 4 、新增加容器—静态数组array、forward_list（单链表）以及unordered_xx系列...
C11 左值引用与右值引用
qq_70799748的博客
05-14 371
通过右值引用的声明，该右值又重获新生，其生命周期与右值引用类型名的生命周期一样。func(b):首先联编func(const int&val),不能与func(int &val)和func(int &&val)联编。常量左值引用是一个万能引用类型，可以接收左值、右值、常量左值和常量右值。通过右值引用，比之前少了一次拷贝构造和一次析构，原因在于右值引用绑定了右值，让临时右值的生命周期延长了。总结：右值引用a是具名右值引用，编译器会将已命名的右值引用视为左值。有左值与右值就有了左值引用与右值引用。
c++11移动语义
qq_36865682的博客
04-20 346
C++11移动语义特性 移动语义的必要性 C++11中将数据分为左值和右值。左值为分配内存地址存储在内存中的值。右值为存储在寄存器中但不分配内存地址的值。所以左值可以取地址而右值不可以取地址。 对于右值对象来说，想要将右值对象存放在容器或数组中会发生：根据右值构造新左值对象->销毁右值对象->将新产生的左值对象存放到容器中。为了简化这个过程的时间空间开销引进移动语义。 移动语义特性 移动语义是指将临时的右值对象构造一个新的左值对象，并且该左值对象不占用新的内存空间。 移动构造函数和移
C++11:移动语义和完美转发
oorik的博客
09-10 915
移动语意对带有资源托管的对象，资源可以转移的且转移后能保证安全的，特别适合，还能降低析构复杂度，一些天生具有不可复制性对象也特别适合，比如unique_ptr。通俗理解就是一些带资源的对象需要拷贝时，想要有浅拷贝的效率，还想要深拷贝析构时安全的效果，正所谓鱼和熊掌不可兼得，其它对象，移动语意可能就没有什么明显的优势。......
C11 列表初始化、左/右值引用、移动语义、可变参数模版
Han同学
04-05 1188
C11 列表初始化、左/右值引用、移动语义、可变参数模版
C++11 新特性：移动语义
最新发布
kelvin_yin的专栏
05-12 1062
C++11 引入的移动语义是对 C++ 语言的一大改进，它提供了一种更有效的资源管理方式，特别是在处理大量数据或资源密集型对象时。移动语义通过引入右值引用（Right-Value Reference，标记为&&）和两个新的构造函数——移动构造函数（Move Constructor）和移动赋值运算符（Move Assignment Operator）——来实现。这些新特性允许开发者优化程序性能，减少不必要的对象拷贝，从而提高效率。
【c++11】看完立马就懂--右值引用！！！
weixin_74127402的博客
04-21 1112
右值引用，左值引用，万能引用，完美转发，移动拷贝
"C11新特性详解：左值引用、右值引用、移动语义、完美转发与列表初始化
首先，C++11引入了左值引用和右值引用的概念，以及与之相关的移动语义和完美转发。左值引用（Lvalue Reference）是对一个左值进行引用的类型，右值引用（Rvalue Reference）是对一个右值进行引用的类型。通过引入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值