C++移动构造与移动赋值详解与解决方案

原创 于 2025-11-30 07:30:00 发布 · 492 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言

C++移动构造与移动赋值详解与解决方案

移动语义是C++11引入的重要特性，旨在消除不必要的拷贝，提升性能。但错误使用会导致资源泄漏、悬空指针等问题。

1. 移动语义基本概念

1.1 左值、右值与移动语义

#include <utility>

class Resource {
private:
    int* data;
    size_t size;
    
public:
    Resource(size_t s) : size(s), data(new int[s]) {}
    
    // 拷贝构造函数（深拷贝）
    Resource(const Resource& other) : size(other.size), data(new int[other.size]) {
        std::copy(other.data, other.data + size, data);
    }
    
    // 移动构造函数（资源转移）
    Resource(Resource&& other) noexcept 
        : data(other.data), size(other.size) {  // 接管资源
        other.data = nullptr;  // 置空源对象
        other.size = 0;
    }
};

void value_categories() {
    Resource a(100);     // a是左值（有名称，有地址）
    Resource b = a;      // 拷贝构造：a是左值
    
    Resource c = Resource(200);  // 移动构造：Resource(200)是右值（临时对象）
    Resource d = std::move(a);   // 移动构造：std::move将左值a转为右值引用
}

1.2 移动语义的优势

#include <vector>
#include <chrono>

class HeavyResource {
private:
    std::vector<int> large_data;
    
public:
    HeavyResource(size_t size) : large_data(size) {
        for (size_t i = 0; i < size; ++i) {
            large_data[i] = i;
        }
    }
    
    // 拷贝构造函数
    HeavyResource(const HeavyResource& other) : large_data(other.large_data) {
        std::cout << "Copy constructor called" << std::endl;
    }
    
    // 移动构造函数
    HeavyResource(HeavyResource&& other) noexcept 
        : large_data(std::move(other.large_data)) {
        std::cout << "Move constructor called" << std::endl;
    }
};

void performance_demo() {
    std::vector<HeavyResource> container;
    
    // 没有移动语义：拷贝整个vector
    HeavyResource resource(1000000);
    container.push_back(resource);  // 拷贝构造
    
    // 有移动语义：转移资源
    container.push_back(HeavyResource(1000000));  // 移动构造
    container.push_back(std::move(resource));     // 移动构造
}

2. 常见问题与陷阱

2.1 移动后使用源对象

// ❌ 错误：移动后使用源对象
class ProblematicMove {
private:
    std::string data;
    
public:
    ProblematicMove(std::string str) : data(std::move(str)) {}
    
    ProblematicMove(ProblematicMove&& other) noexcept 
        : data(std::move(other.data)) {
        // other.data现在处于有效但未指定状态
    }
    
    void use_after_move() {
        ProblematicMove obj("Hello");
        ProblematicMove stolen = std::move(obj);
        
        std::cout << obj.data << std::endl;  // 未定义行为！
        // obj.data可能为空，也可能是"Hello"，具体取决于std::string的实现
    }
};

2.2 没有标记为noexcept

// ❌ 错误：移动操作可能抛出异常
class ThrowingMove {
private:
    std::vector<int> data;
    std::unique_ptr<int[]> buffer;
    
public:
    ThrowingMove(std::vector<int> d, size_t buf_size) 
        : data(std::move(d)), buffer(std::make_unique<int[]>(buf_size)) {}
    
    // 移动构造函数没有noexcept
    ThrowingMove(ThrowingMove&& other) {
        data = std::move(other.data);           // 不会抛出
        buffer = std::move(other.buffer);       // 不会抛出
        // 但编译器不知道，所以不会标记为noexcept
    }
};

void noexcept_importance() {
    std::vector<ThrowingMove> container;
    ThrowingMove obj({1,2,3}, 100);
    
    // 如果移动构造函数不是noexcept，vector可能选择拷贝而不是移动
    container.push_back(std::move(obj));
}

2.3 资源泄漏

// ❌ 错误：移动赋值运算符资源泄漏
class LeakingMove {
private:
    int* data;
    size_t size;
    
public:
    LeakingMove(size_t s) : size(s), data(new int[s]) {}
    
    // 移动构造函数正确
    LeakingMove(LeakingMove&& other) noexcept 
        : data(other.data), size(other.size) {
        other.data = nullptr;
        other.size = 0;
    }
    
    // 移动赋值运算符错误：没有释放现有资源
    LeakingMove& operator=(LeakingMove&& other) noexcept {
        // 忘记：delete[] data;
        data = other.data;    // 资源泄漏！
        size = other.size;
        other.data = nullptr;
        other.size = 0;
        return *this;
    }
    
    ~LeakingMove() {
        delete[] data;
    }
};

2.4 自移动赋值

// ❌ 错误：没有处理自移动赋值
class SelfMove {
private:
    std::unique_ptr<int[]> data;
    size_t size;
    
public:
    SelfMove(size_t s) : size(s), data(std::make_unique<int[]>(s)) {}
    
    SelfMove& operator=(SelfMove&& other) noexcept {
        // 没有自移动赋值检查
        data = std::move(other.data);  // 如果是自移动赋值，这里会移动自己
        size = other.size;
        return *this;
    }
};

void self_move_demo() {
    SelfMove obj(100);
    obj = std::move(obj);  // 自移动赋值：obj.data现在为空！
}

3. 正确实现模式

3.1 基本的移动操作实现

// ✅ 正确的移动操作实现
class CorrectMove {
private:
    std::unique_ptr<int[]> data;
    size_t size;
    
public:
    CorrectMove(size_t s = 0) : size(s), data(size > 0 ? std::make_unique<int[]>(size) : nullptr) {}
    
    // 拷贝构造函数
    CorrectMove(const CorrectMove& other) : size(other.size) {
        if (size > 0) {
            data = std::make_unique<int[]>(size);
            std::copy(other.data.get(), other.data.get() + size, data.get());
        }
    }
    
    // 移动构造函数
    CorrectMove(CorrectMove&& other) noexcept 
        : data(std::move(other.data)), size(other.size) {
        other.size = 0;
    }
    
    // 拷贝赋值运算符
    CorrectMove& operator=(const CorrectMove& other) {
        if (this != &other) {
            if (size != other.size) {
                data = std::make_unique<int[]>(other.size);
                size = other.size;
            }
            if (size > 0) {
                std::copy(other.data.get(), other.data.get() + size, data.get());
            }
        }
        return *this;
    }
    
    // 移动赋值运算符
    CorrectMove& operator=(CorrectMove&& other) noexcept {
        if (this != &other) {  // 自移动赋值检查
            data = std::move(other.data);
            size = other.size;
            other.size = 0;
        }
        return *this;
    }
    
    ~CorrectMove() = default;  // unique_ptr自动处理资源释放
};

3.2 拷贝并交换惯用法的移动支持

// ✅ 使用拷贝并交换支持移动语义
class CopyAndSwapWithMove {
private:
    std::vector<int> data;
    std::string name;
    
    friend void swap(CopyAndSwapWithMove& first, CopyAndSwapWithMove& second) noexcept {
        using std::swap;
        swap(first.data, second.data);
        swap(first.name, second.name);
    }
    
public:
    CopyAndSwapWithMove(std::string n, std::vector<int> d) 
        : name(std::move(n)), data(std::move(d)) {}
    
    // 拷贝构造函数
    CopyAndSwapWithMove(const CopyAndSwapWithMove&) = default;
    
    // 移动构造函数
    CopyAndSwapWithMove(CopyAndSwapWithMove&& other) noexcept 
        : CopyAndSwapWithMove("", {}) {  // 委托构造创建空对象
        swap(*this, other);              // 然后交换
    }
    
    // 统一的赋值运算符（处理拷贝和移动）
    CopyAndSwapWithMove& operator=(CopyAndSwapWithMove other) noexcept {
        swap(*this, other);
        return *this;
    }
    
    // 注意：不需要单独定义移动赋值运算符，上面的版本已经处理了
    
    ~CopyAndSwapWithMove() = default;
};

3.3 基于RAII的自动移动语义

// ✅ 使用RAII类型自动获得移动语义
class RAIIBasedMove {
private:
    std::vector<std::string> strings;    // 自动支持移动
    std::unique_ptr<int[]> data;         // 自动支持移动  
    std::shared_ptr<Config> config;      // 自动支持移动（共享）
    
public:
    RAIIBasedMove(size_t data_size, std::vector<std::string> strs, 
                  std::shared_ptr<Config> cfg)
        : strings(std::move(strs)), 
          data(data_size > 0 ? std::make_unique<int[]>(data_size) : nullptr),
          config(std::move(cfg)) {}
    
    // 不需要自定义移动操作！
    // 编译器生成的版本会正确移动所有成员
    
    // 显式默认以明确意图
    RAIIBasedMove(const RAIIBasedMove&) = default;
    RAIIBasedMove(RAIIBasedMove&&) noexcept = default;
    RAIIBasedMove& operator=(const RAIIBasedMove&) = default;
    RAIIBasedMove& operator=(RAIIBasedMove&&) noexcept = default;
    ~RAIIBasedMove() = default;
    
    // 提供深拷贝接口（如果需要）
    RAIIBasedMove deepCopy() const {
        RAIIBasedMove copy = *this;  // 浅拷贝
        
        // 对需要深拷贝的成员进行特殊处理
        if (data) {
            size_t size = /* 需要记录大小 */;
            copy.data = std::make_unique<int[]>(size);
            std::copy(data.get(), data.get() + size, copy.data.get());
        }
        
        return copy;
    }
};

4. 高级主题与最佳实践

4.1 条件性noexcept

#include <type_traits>

class ConditionalNoexcept {
private:
    std::vector<int> data;
    std::string name;
    
public:
    ConditionalNoexcept(std::string n, std::vector<int> d) 
        : name(std::move(n)), data(std::move(d)) {}
    
    // 移动构造函数：根据成员移动操作是否noexcept
    ConditionalNoexcept(ConditionalNoexcept&& other) 
        noexcept(std::is_nothrow_move_constructible_v<std::vector<int>> &&
                std::is_nothrow_move_constructible_v<std::string>)
        : data(std::move(other.data)), name(std::move(other.name)) {}
    
    // 移动赋值运算符：条件性noexcept
    ConditionalNoexcept& operator=(ConditionalNoexcept&& other)
        noexcept(std::is_nothrow_move_assignable_v<std::vector<int>> &&
                std::is_nothrow_move_assignable_v<std::string>) {
        if (this != &other) {
            data = std::move(other.data);
            name = std::move(other.name);
        }
        return *this;
    }
};

4.2 移动感知的成员函数

class MoveAware {
private:
    std::vector<int> data;
    
public:
    MoveAware(std::vector<int> d) : data(std::move(d)) {}
    
    // 针对左值的版本
    void addData(const std::vector<int>& new_data) & {
        std::cout << "Adding data by copy\n";
        data.insert(data.end(), new_data.begin(), new_data.end());
    }
    
    // 针对右值的版本
    void addData(std::vector<int>&& new_data) & {
        std::cout << "Adding data by move\n";
        // 直接移动，避免拷贝
        if (data.empty()) {
            data = std::move(new_data);
        } else {
            data.insert(data.end(), 
                       std::make_move_iterator(new_data.begin()),
                       std::make_move_iterator(new_data.end()));
        }
    }
    
    // 在右值对象上调用时的版本
    void addData(const std::vector<int>& new_data) && {
        std::cout << "Adding data to temporary object\n";
        // 因为是临时对象，可以直接修改
        data.insert(data.end(), new_data.begin(), new_data.end());
    }
};

void use_move_aware() {
    MoveAware obj({1, 2, 3});
    std::vector<int> new_data{4, 5, 6};
    
    obj.addData(new_data);           // 调用拷贝版本
    obj.addData(std::move(new_data)); // 调用移动版本
    MoveAware({1,2,3}).addData({4,5,6}); // 调用右值版本
}

4.3 完美转发在移动语义中的应用

class PerfectForwarding {
private:
    std::vector<std::string> items;
    
public:
    // 完美转发构造函数
    template<typename T, typename... Args>
    void emplaceBack(T&& first, Args&&... args) {
        // 完美转发所有参数
        items.emplace_back(std::forward<T>(first), std::forward<Args>(args)...);
    }
    
    // 设置数据的完美转发版本
    template<typename T>
    void setData(T&& new_data) {
        // 根据传入的是左值还是右值，选择拷贝或移动
        items = std::forward<T>(new_data);
    }
};

void use_perfect_forwarding() {
    PerfectForwarding pf;
    std::vector<std::string> data{"hello", "world"};
    
    pf.emplaceBack("test");              // 转发const char*
    pf.setData(data);                    // 拷贝
    pf.setData(std::move(data));         // 移动
    
    std::string temp = "temporary";
    pf.emplaceBack(std::move(temp));     // 移动
}

5. 特定场景解决方案

5.1 包含不可移动成员的处理

class WithImmobileMember {
private:
    std::atomic<int> counter;  // 不可移动
    std::vector<int> data;     // 可移动
    
public:
    WithImmobileMember(int init_count, std::vector<int> d) 
        : counter(init_count), data(std::move(d)) {}
    
    // 移动构造函数：需要特殊处理不可移动成员
    WithImmobileMember(WithImmobileMember&& other) noexcept 
        : counter(other.counter.load()),  // 原子变量需要显式拷贝
          data(std::move(other.data)) {   // 其他成员可以移动
    }
    
    // 移动赋值运算符
    WithImmobileMember& operator=(WithImmobileMember&& other) noexcept {
        if (this != &other) {
            counter.store(other.counter.load());  // 原子操作
            data = std::move(other.data);
        }
        return *this;
    }
    
    // 注意：原子类型不可移动，但可以拷贝其值
};

5.2 多态基类的移动语义

class CloneableBase {
public:
    virtual ~CloneableBase() = default;
    
    // 禁止拷贝但允许移动
    CloneableBase(const CloneableBase&) = delete;
    CloneableBase& operator=(const CloneableBase&) = delete;
    
    // 默认移动操作
    CloneableBase(CloneableBase&&) = default;
    CloneableBase& operator=(CloneableBase&&) = default;
    
    // 克隆接口
    virtual std::unique_ptr<CloneableBase> clone() const = 0;
    
    // 移动克隆接口
    virtual std::unique_ptr<CloneableBase> move_clone() && = 0;
};

class Derived : public CloneableBase {
private:
    std::vector<int> data;
    std::string name;
    
public:
    Derived(std::string n, std::vector<int> d) 
        : name(std::move(n)), data(std::move(d)) {}
    
    std::unique_ptr<CloneableBase> clone() const override {
        return std::make_unique<Derived>(*this);
    }
    
    std::unique_ptr<CloneableBase> move_clone() && override {
        return std::make_unique<Derived>(std::move(*this));
    }
    
    // 派生类需要可移动
    Derived(Derived&&) = default;
    Derived& operator=(Derived&&) = default;
    
    // 注意：基类已删除拷贝操作，派生类也不能拷贝
};

5.3 移动语义与异常安全

class ExceptionSafeMove {
private:
    std::unique_ptr<int[]> part1;
    std::unique_ptr<double[]> part2;
    std::string name;
    
public:
    ExceptionSafeMove(size_t s1, size_t s2, std::string n) 
        : part1(s1 > 0 ? std::make_unique<int[]>(s1) : nullptr),
          part2(s2 > 0 ? std::make_unique<double[]>(s2) : nullptr),
          name(std::move(n)) {}
    
    // 强异常安全的移动赋值
    ExceptionSafeMove& operator=(ExceptionSafeMove&& other) noexcept {
        if (this != &other) {
            // 先创建临时对象接管新资源
            auto new_part1 = std::move(other.part1);
            auto new_part2 = std::move(other.part2);
            auto new_name = std::move(other.name);
            
            // 然后交换（不会抛出异常）
            part1 = std::move(new_part1);
            part2 = std::move(new_part2);
            name = std::move(new_name);
        }
        return *this;
    }
    
    // 或者使用交换惯用法
    friend void swap(ExceptionSafeMove& first, ExceptionSafeMove& second) noexcept {
        using std::swap;
        swap(first.part1, second.part1);
        swap(first.part2, second.part2);
        swap(first.name, second.name);
    }
    
    ExceptionSafeMove& operator=(ExceptionSafeMove other) noexcept {
        swap(*this, other);
        return *this;
    }
};

6. 测试与验证

6.1 移动语义正确性测试

#include <cassert>

void test_move_semantics() {
    // 测试移动构造函数
    {
        CorrectMove original(100);
        int* original_data = original.getData();  // 假设有getData()方法
        
        CorrectMove moved = std::move(original);
        
        assert(moved.getData() == original_data);  // 资源被转移
        assert(original.getData() == nullptr);     // 源对象被置空
        assert(original.getSize() == 0);
    }
    
    // 测试移动赋值运算符
    {
        CorrectMove a(50);
        CorrectMove b(100);
        int* a_data = a.getData();
        
        b = std::move(a);
        
        assert(b.getData() == a_data);    // 资源转移
        assert(a.getData() == nullptr);   // 源对象置空
    }
    
    // 测试自移动赋值
    {
        CorrectMove obj(75);
        int* original_data = obj.getData();
        
        obj = std::move(obj);  // 应该没有影响
        
        assert(obj.getData() == original_data);  // 资源保持不变
        assert(obj.getSize() == 75);
    }
    
    // 测试异常安全
    {
        ExceptionSafeMove obj1(10, 20, "test1");
        ExceptionSafeMove obj2(30, 40, "test2");
        
        // 移动赋值应该是异常安全的
        obj1 = std::move(obj2);
        
        assert(obj1.getName() == "test2");
        assert(obj2.getName().empty());  // 被移动后的有效状态
    }
    
    std::cout << "All move semantics tests passed!" << std::endl;
}

6.2 性能测试

#include <chrono>

class PerformanceTest {
private:
    std::vector<int> data;
    
public:
    PerformanceTest(size_t size) : data(size) {
        std::iota(data.begin(), data.end(), 0);
    }
    
    // 拷贝构造函数
    PerformanceTest(const PerformanceTest& other) : data(other.data) {}
    
    // 移动构造函数
    PerformanceTest(PerformanceTest&& other) noexcept : data(std::move(other.data)) {}
};

void benchmark_move_vs_copy() {
    const int iterations = 10000;
    const size_t data_size = 10000;
    
    // 测试拷贝性能
    auto start = std::chrono::high_resolution_clock::now();
    std::vector<PerformanceTest> copy_container;
    copy_container.reserve(iterations);
    
    PerformanceTest prototype(data_size);
    for (int i = 0; i < iterations; ++i) {
        copy_container.push_back(prototype);  // 拷贝
    }
    auto copy_time = std::chrono::high_resolution_clock::now() - start;
    
    // 测试移动性能
    start = std::chrono::high_resolution_clock::now();
    std::vector<PerformanceTest> move_container;
    move_container.reserve(iterations);
    
    for (int i = 0; i < iterations; ++i) {
        PerformanceTest temp(data_size);
        move_container.push_back(std::move(temp));  // 移动
    }
    auto move_time = std::chrono::high_resolution_clock::now() - start;
    
    std::cout << "Copy time: " 
              << std::chrono::duration_cast<std::chrono::milliseconds>(copy_time).count() 
              << " ms" << std::endl;
    std::cout << "Move time: " 
              << std::chrono::duration_cast<std::chrono::milliseconds>(move_time).count() 
              << " ms" << std::endl;
}

7. 最佳实践总结

7.1 移动语义设计原则

// 移动语义最佳实践模板
class MoveBestPractices {
private:
    std::vector<int> data;
    std::string name;
    std::unique_ptr<Resource> resource;
    
public:
    MoveBestPractices(std::string n, std::vector<int> d, std::unique_ptr<Resource> res)
        : name(std::move(n)), data(std::move(d)), resource(std::move(res)) {}
    
    // 1. 移动操作标记为noexcept
    MoveBestPractices(MoveBestPractices&& other) noexcept
        : data(std::move(other.data)),
          name(std::move(other.name)),
          resource(std::move(other.resource)) {}
    
    // 2. 移动赋值运算符处理自赋值
    MoveBestPractices& operator=(MoveBestPractices&& other) noexcept {
        if (this != &other) {
            data = std::move(other.data);
            name = std::move(other.name);
            resource = std::move(other.resource);
        }
        return *this;
    }
    
    // 3. 移动后置源对象于有效状态
    //    对于标准库类型，移动后处于"有效但未指定状态"
    //    对于自定义类型，通常置为默认构造状态
    
    // 4. 优先使用编译器生成的版本（规则零）
    // 5. 需要时使用拷贝并交换惯用法
    
    ~MoveBestPractices() = default;
};

7.2 使用场景指南

场景推荐做法注意事项
管理动态资源实现移动操作，转移资源所有权确保noexcept，处理自赋值
包含标准库成员使用编译器生成的移动操作大多数情况不需要自定义
性能敏感代码提供移动感知的重载使用引用限定符
多态基类默认移动操作，或禁止拷贝允许移动注意切片问题
异常安全要求使用交换惯用法确保交换操作noexcept

7.3 常见陷阱总结

// ❌ 避免这些陷阱
class MovePitfalls {
public:
    // 陷阱1：移动后使用源对象
    void pitfall1() {
        std::string str = "hello";
        std::string stolen = std::move(str);
        // cout << str;  // 错误：str处于有效但未指定状态
    }
    
    // 陷阱2：移动操作不是noexcept
    // 这会影响标准库容器的效率
    
    // 陷阱3：忘记释放现有资源（移动赋值）
    
    // 陷阱4：没有处理自移动赋值
    
    // 陷阱5：在返回值中使用std::move（抑制RVO）
    std::vector<int> createVector() {
        std::vector<int> result{1, 2, 3};
        return result;           // 正确：可能RVO或移动
        // return std::move(result);  // 错误：抑制RVO
    }
};

通过遵循这些最佳实践，可以安全高效地使用移动语义，显著提升C++程序的性能，同时避免常见的陷阱和错误。

【C++11保姆级教程】移动构造函数（move constructor）和移动赋值操作符（move assignment operator）
m0_62599305的博客
08-19 1万+
在C++11标准中引入了移动语义的概念，通过移动构造函数和移动赋值操作符，我们可以更高效地管理对象的资源。本文将以通俗易懂的方式详细解释移动构造函数和移动赋值操作符的概念，并通过生动的比喻帮助读者更好地理解这两个概念。当我们需要在C++中处理大量数据或动态分配的对象时，移动构造函数和移动赋值操作符成为了重要的工具。它们是C++11引入的特性，旨在提高程序的性能和效率。
C++11 右值，右值引用，移动构造，移动赋值
TPON的博客
11-26 1976
左值，右值，左值引用，右值引用，移动构造，拷贝构造，模板中的万能引用T&&，完美转发
C++ 移动构造函数与 move 语义
平平无奇的小甜菜
10-10 946
摘要：本文介绍了C++11中的移动构造函数及其应用。移动构造函数通过接管临时对象的资源而非拷贝。其语法采用右值引用并需声明noexcept，关键步骤是接管资源后将源对象置空。
C++11移动构造函数详解
TABE_的博客
12-29 8627
这里写目录标题拷贝构造函数修改后的拷贝构造函数移动构造函数移动构造函数的优点 当类中同时包含拷贝构造函数和移动构造函数时，如果使用临时对象初始化当前类的对象，编译器会优先调用移动构造函数来完成此操作。只有当类中没有合适的移动构造函数时，编译器才会退而求其次，调用拷贝构造函数。 拷贝构造函数 C++在三种情况下会调用拷贝构造函数（可能有纰漏），第一种情况是函数形实结合时，第二种情况是函数返回时，函数栈区的对象会复制一份到函数的返回去，第三种情况是用一个对象初始化另一个对象时也会调用拷贝构造函数。 除了这三种情
C++ 移动构造函数详解
热门推荐
a只如初见的博客
08-12 3万+
1、移动构造是C++11标准中提供的一种新的构造方法2、移动构造接管源对象，既不会产生额外的拷贝开销，也不会给新对象分配内存空间。提高程序的执行效率，节省内存消耗。3、移动构造函数的第一个参数必须是自身类型的右值引用...
移动构造-C++11
沐埜专栏
09-28 2万+
移动构造： 移动构造是C++11标准中提供的一种新的构造方法。 在现实中有很多这样的例子，我们将钱从一个账号转移到另一个账号，将手机SIM卡转移到另一台手机，将文件从一个位置剪切到另一个位置……     移动构造可以减少不必要的复制，带来性能上的提升。 有些复制构造是必要的，我们确实需要另外一个副本；而有些复制构造是不必要的，我们可能只是希望这个对象换个地方，移动一下而已。 在C++11
C++三大函数详解：拷贝构造、赋值运算与析构应用
此外，现代C++还引入了移动语义（Move Semantics）与“五法则”（Rule of Five），即在三法则基础上增加移动构造函数和移动赋值运算符，进一步优化性能，减少不必要的深拷贝开销。掌握这些核心机制不仅有助于编写...
22、C++ 运算符、异常处理、移动构造与递归详解
最新发布
a0b1c2d3的专栏
10-13 14
本文深入讲解C++中的核心特性，包括运算符重载、异常处理机制、移动构造与赋值运算符的性能优化、递归原理及其应用。通过String类和Point2D等实例，详细阐述了各特性的实现方式与最佳实践，并结合实际案例分析和未来发展趋势，帮助开发者提升代码效率与健壮性。
C++移动构造函数详解：如何安全、高效地移动资源
[C++移动构造函数详解：如何安全、高效地移动资源](https://img-blog.csdnimg.cn/direct/81b7a0a47d7a44e59110dce85fac3cc9.png) # 1. C++移动构造函数基础 C++作为一种高效、灵活的编程语言，其演进一直聚焦于性能...
C++虚拟基类与std::shared_ptr的移动赋值陷阱：当智能指针遇上菱形继承
weixin_61470881的博客
01-08 1086
/ 确保只对虚基类赋值一次// 如果B或C有非虚基类成员，需要在这里处理// 同时也应该定义移动构造函数// 如果需要，处理B和C的非虚基类成员这个案例深入展示了C++中虚拟继承和智能指针相互作用时的复杂性。设计层面理解语言特性的细节和限制注意标准中的未指定行为谨慎使用虚拟继承和移动语义实现层面显式定义特殊成员函数使用适当的智能指针类型采用值语义而非指针语义维护层面编写完善的单元测试添加必要的调试信息保持代码简单和可维护。
C++构造函数详解与国产化软硬件发展趋势
书中详细讲解了C++的基础知识，包括面向对象编程的概念，如封装、抽象、继承和多态，以及现代C++的特性，如lambda表达式、智能指针、移动构造函数和赋值运算符。此外，还强调了使用标准模板库（STL）中的容器和算法...
【C++ | 移动构造函数】C++11的 移动构造函数 详解及例子代码
wkd_007的博客
06-12 9404
👉本文介绍C++11的移动构造函数，讲解了为什么需要移动构造函数，怎样声明、定义移动构造函数，怎样使用移动构造函数。 移动构造函数的目的就是为了减少一次拷贝，提升性能。C++11主要通过右值引用来实现移动语义，在使用右值(即将销毁的对象)去创建对象时，调用移动构造函数而不调用拷贝构造函数，以此减少一次拷贝。
拷贝构造函数和移动构造函数
qq_43287763的博客
03-07 3935
从C++11开始，可以使用`= default;`和`= delete;`来显式地要求编译器默认生成或禁用这些函数。
移动构造函数
qqwangfan的专栏
07-02 2138
文章目录 一、引言 二、左值和右值 三、深拷贝构造函数 四、右值引用 五、移动构造函数 六、std::move() 七、参考资料 一、引言 移动构造函数是什么？先举个例子，你有一本书，你不想看，但我很想看，那么我有哪些方法可以让我能看这本书？有两种做法，一种是你直接把书交给我，另一种是我去买一些稿纸来，然后照着你这本书一字一句抄到稿纸上。 显然，第二种方法很浪费时间，但这正是有些深拷贝构造函数的做法，而移动构造函数便能像第一种做法一样省时，第一种做法在 C++ 中叫做完美转发。 二、左值和右值 何为左值？能
C++之移动构造函数
bin_bujiangjiu的博客
11-28 2793
C++ 移动构造函数
深入分析移动构造函数及其原理
u012159565的专栏
03-06 1493
std::move
详解 C++ 中移动构造与移动赋值
comedate的专栏
01-27 1465
本文介绍了 C++ 中的移动构造与移动赋值语法的原理，并通过基类，子类的例子，说明了移动构造赋值的写法；
C++移动构造函数
sinat_31608641的博客
05-14 2003
移动构造函数是参数类型为右值引用的拷贝构造函数类名 ( 类名&&(1)(C++11 起)class_name ( 类名&&(2)(C++11 起)class_name ( 类名&&) = delete;默认情况下，左值初始化同类对象只能通过拷贝构造函数完成，如果想调用移动构造函数，则必须使用右值进行初始化。C++11 标准中为了满足用户使用左值初始化同类对象时，也通过移动构造函数完成的需求，新引入了 std::move() 函数，它可以将左值强制转换成对应的右值，由此便可以使用移动构造函数。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值