当前位置： 首页 > article >正文

【DeepSeek学C++】移动构造函数

article 2025/3/31 20:32:15

1. 移动操作也仅在需要时才生成而一旦生成它们执行的也是作用于非静态成员的按成员移动操作

在C++中，移动构造函数和移动赋值运算符的自动生成及行为遵循以下规则：

  1. 生成条件与时机
    隐式生成条件：当类中未显式声明拷贝操作（拷贝构造函数、拷贝赋值运算符）、移动操作（移动构造函数、移动赋值运算符）或析构函数时，编译器会隐式生成默认的移动操作。

“需要时才生成”的含义：编译器在类定义时声明这些移动操作，但实际代码的生成（实例化）发生在它们被**使用（ODR-used）**时。例如，当代码中执行std::move(obj)或返回对象触发移动时，编译器才会生成具体的移动操作代码，避免不必要的代码膨胀。

  1. 按成员移动的行为
    对非静态成员的处理：生成的移动操作会逐个处理每个非静态成员：

若成员是类类型，调用其对应的移动构造函数或移动赋值运算符。

若成员是内置类型（如int），执行简单的拷贝（因内置类型无移动语义，移动等同于拷贝）。

继承体系中的行为：对基类部分也会递归执行移动操作，确保整个对象层次结构的正确移动。

  1. 隐式删除与回退机制
    移动操作的隐式删除：若某个成员或基类不可移动（如包含const成员或未实现移动操作的类），则编译器会删除该类的默认移动操作。

回退到拷贝操作：当移动操作不可用时（未生成或被删除），尝试移动对象会回退到拷贝操作（调用拷贝构造函数或拷贝赋值运算符），可能导致性能损失。

struct Member {
    Member() = default;
    Member(Member&&) = default; // 成员自定义移动构造函数
};

struct MyClass {
    Member m;       // 类类型成员，支持移动
    int i;          // 内置类型，移动即拷贝

    // 编译器隐式生成移动构造函数：
    // MyClass(MyClass&& other) : m(std::move(other.m)), i(other.i) {}
};

int main() {
    MyClass a;
    MyClass b = std::move(a); // 触发隐式生成的移动构造函数
}

移动操作生成条件：类无用户声明的拷贝/移动操作或析构函数。

按成员移动：对每个成员递归应用移动语义，内置类型执行拷贝。

实际生成时机：在代码中首次使用时实例化，优化编译结果。

理解这些机制有助于避免因隐式行为导致的性能问题，确保在需要移动语义时，类的设计允许编译器正确生成高效操作。

2 对非静态成员的处理*：生成的移动操作会逐个处理每个非静态成员： 这句话什么意思。为什么是非静态成员

静态成员属于类本身，而非静态成员属于类的每个实例。因此，当移动一个对象时，静态成员并不属于对象实例的一部分，所以不需要移动。移动操作是针对对象实例的，所以只处理非静态成员。

接下来，用户可能需要具体的例子来理解这一点。例如，如果有类中包含静态成员变量，移动操作不会去处理它，因为静态成员是所有实例共享的，移动一个实例不会影响其他实例的静态成员值。而非静态成员每个实例都有自己的一份，所以需要逐个移动
在这里插入图片描述

struct Example {
    int non_static_member;  // 非静态成员：每个对象独立
    static int static_member; // 静态成员：所有对象共享

    // 隐式生成的移动构造函数：
    // Example(Example&& other) : non_static_member(std::move(other.non_static_member)) {}
    // 静态成员 static_member 不参与移动！
};

在这里插入图片描述
在这里插入图片描述

3 移动操作仅在需要时才生成 什么意思？请举例说明。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

5. 移动构造和赋值会移动和赋值它的基类部分 什么意思 请举例说明

这里的“基类部分”指的是派生类对象中包含的基类子对象。在C++中，当处理派生类的移动操作时，必须正确处理基类部分，否则可能导致资源泄漏或不正确的状态。

我需要解释，当编译器隐式生成派生类的移动构造函数和移动赋值运算符时，它们会自动调用基类的对应移动操作。如果基类有合适的移动操作，派生类的移动操作会正确转移基类部分的资源。如果用户显式定义了派生类的移动操作但没有正确处理基类部分，可能会导致基类部分没有被正确移动，从而引发问题。
在这里插入图片描述

  1. 隐式生成的移动操作处理基类
#include <iostream>
#include <string>

// 基类
class Base {
public:
    Base() = default;
    Base(Base&& other) : data(std::move(other.data)) {
        std::cout << "Base移动构造函数" << std::endl;
    }
    Base& operator=(Base&& other) {
        data = std::move(other.data);
        std::cout << "Base移动赋值运算符" << std::endl;
        return *this;
    }
private:
    std::string data;  // 可移动的成员
};

// 派生类
class Derived : public Base {
public:
    // 编译器隐式生成移动构造函数和移动赋值运算符
    // 会调用基类的对应移动操作
private:
    int value;  // 内置类型成员
};

int main() {
    Derived a;
    Derived b = std::move(a);  // 调用隐式生成的移动构造函数
    Derived c;
    c = std::move(b);          // 调用隐式生成的移动赋值运算符
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

6 基类和子类都不声明拷贝构造和移动构造拷贝复制和移动复制， 当子类实例移动时 会为子类和父类都生成移动构造 和移动赋值吗

当子类隐式生成移动构造函数时，它会自动调用基类的移动构造函数。如果基类本身没有声明任何拷贝或移动操作，那么基类的移动构造函数也会被隐式生成。同样，移动赋值运算符也是如此。
在这里插入图片描述
在这里插入图片描述
3. 具体行为分析
(1) 移动构造函数
派生类 Derived：
编译器隐式生成 Derived(Derived&& other)，其行为如下：

// 隐式生成的移动构造函数伪代码
Derived(Derived&& other)
    : Base(std::move(other)),         // 调用 Base 的移动构造函数
      value(std::move(other.value))  // 移动内置类型成员（实际是拷贝）
{}

基类 Base：编译器同样隐式生成 Base(Base&& other)，其行为为：

// 隐式生成的基类移动构造函数伪代码
Base(Base&& other)
    : data(std::move(other.data))  // 调用 std::string 的移动构造函数
{}

(2) 移动赋值运算符
派生类 Derived：
编译器隐式生成 Derived& operator=(Derived&& other)，其行为如下：

// 隐式生成的移动赋值运算符伪代码
Derived& operator=(Derived&& other) {
    Base::operator=(std::move(other));  // 调用 Base 的移动赋值运算符
    value = std::move(other.value);     // 移动内置类型成员（实际是拷贝）
    return *this;
}

基类 Base：
编译器隐式生成 Base& operator=(Base&& other)，其行为为：

// 隐式生成的基类移动赋值运算符伪代码
Base& operator=(Base&& other) {
    data = std::move(other.data);  // 调用 std::string 的移动赋值运算符
    return *this;
}

在这里插入图片描述

7为什么生成析构函数 就不会生生成移动操作

这可能是因为析构函数的存在表明类可能需要管理资源，因此默认的移动操作可能不安全。

接下来，需要解释为什么析构函数的声明会影响移动操作的生成。可能涉及到“三法则”或“五法则”，即如果一个类需要自定义析构函数、拷贝构造函数或拷贝赋值运算符，那么它通常也需要自定义移动操作，反之亦然。

需要举例说明，比如一个类有指针成员，用户定义了析构函数来释放内存，这时候编译器不会生成移动操作，因为默认的移动操作可能只是浅拷贝，导致重复释放
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
实际测试， 析构函数不会阻止生成移动构造函数。
在这里插入图片描述
上图中默认调用拷贝构造函数是错的. 会生成合成的移动构造函数.调用了移动构造函数.

当显示声明 拷贝构造时, 阻止生成移动构造, 因此才出现未定义行为.
在这里插入图片描述

在这里插入图片描述

当类中不包含复制构造函数。存在移动赋值函数时 会，还会自动生成复制构造函数嘛

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

当显示声明析构函数，是不是不会生成复制构造或者复制赋值函数

用户的问题可能是想确认是否显式声明析构函数会阻止编译器生成拷贝操作。根据我的知识，显式声明析构函数并不会阻止编译器生成拷贝构造函数和拷贝赋值运算符。但是，如果用户需要管理资源，通常需要遵循三法则，即如果声明了析构函数，通常也需要声明拷贝构造函数和拷贝赋值运算符，或者禁用它们。
在这里插入图片描述
三法则（Rule of Three）的指导 : 显示定义析构函数，要显示定义拷贝构造和拷贝赋值。
虽然显式声明析构函数不会阻止默认拷贝操作的生成，但如果类需要管理资源（如动态内存、文件句柄等），应遵循三法则：
显式定义析构函数：释放资源。
显式定义拷贝构造函数和拷贝赋值运算符：确保深拷贝资源，避免浅拷贝导致的问题。

class SafeArray {
public:
    SafeArray(int size) : size(size), data(new int[size]) {}
    ~SafeArray() { delete[] data; }  // 析构函数

    // 显式定义拷贝操作（深拷贝）
    SafeArray(const SafeArray& other) : size(other.size), data(new int[other.size]) {
        std::copy(other.data, other.data + size, data);
    }
    SafeArray& operator=(const SafeArray& other) {
        if (this != &other) {
            delete[] data;
            size = other.size;
            data = new int[size];
            std::copy(other.data, other.data + size, data);
        }
        return *this;
    }

private:
    int* data;
    int size;
};

违反三法则的例子中 不会生成默认 拷贝构造函数嘛 ，生成的默认拷贝构造函数是向什么样的呢

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  1. 为什么用户需要显式定义拷贝操作？
    默认生成的拷贝构造函数无法正确处理资源管理（如动态内存）：

深拷贝需求：
需要手动为新对象分配独立的内存，并复制原对象的数据。

避免悬垂指针：
确保每个对象拥有独立的资源，避免多个对象共享同一资源。

正确实现深拷贝

class SafeArray {
public:
    SafeArray(int size) : size(size), data(new int[size]) {}

    // 1. 析构函数
    ~SafeArray() { delete[] data; }

    // 2. 深拷贝的拷贝构造函数
    SafeArray(const SafeArray& other) : size(other.size), data(new int[other.size]) {
        std::copy(other.data, other.data + size, data);
    }

    // 3. 深拷贝的拷贝赋值运算符
    SafeArray& operator=(const SafeArray& other) {
        if (this != &other) {
            delete[] data;
            size = other.size;
            data = new int[size];
            std::copy(other.data, other.data + size, data);
        }
        return *this;
    }

private:
    int* data;
    int size;
};

三法则的核心意义：
当类管理资源时，必须显式定义拷贝构造函数、拷贝赋值运算符和析构函数，以确保资源的正确深拷贝和释放。尤其显示定义析构函数删除资#源，则必须显式定义拷贝构造函数、拷贝赋值运算符

五法则是什么？

定义了析构函数删除资源， 则三法则必须定义拷贝复制函数， 定义了这两个， 就会阻止编译器生成默认移动函数。这个时候移动就变成复制了，低效。因此要调用移动构造函数

class ResourceHolder {
public:
    // 构造函数
    ResourceHolder(int size) : data(new int[size]), size(size) {}

    // 1. 析构函数
    ~ResourceHolder() { delete[] data; }

    // 2. 拷贝构造函数（深拷贝）
    ResourceHolder(const ResourceHolder& other) 
        : data(new int[other.size]), size(other.size) {
        std::copy(other.data, other.data + size, data);
    }

    // 3. 拷贝赋值运算符（深拷贝）
    ResourceHolder& operator=(const ResourceHolder& other) {
        if (this != &other) {
            delete[] data;
            data = new int[other.size];
            size = other.size;
            std::copy(other.data, other.data + size, data);
        }
        return *this;
    }

    // 4. 移动构造函数（转移资源）
    ResourceHolder(ResourceHolder&& other) noexcept 
        : data(other.data), size(other.size) {
        other.data = nullptr;  // 原对象置空，避免重复释放
        other.size = 0;
    }

    // 5. 移动赋值运算符（转移资源）
    ResourceHolder& operator=(ResourceHolder&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            size = other.size;
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }

private:
    int* data;
    int size;
};

在这里插入图片描述
现代 C++ 的简化方案
使用智能指针：
例如 std::unique_ptr 或 std::shared_ptr 可以自动管理资源，避免手动实现五法则。

#include <memory>
class SafeResourceHolder {
public:
    SafeResourceHolder(int size) : data(std::make_unique<int[]>(size)) {}
    // 无需定义析构、拷贝、移动操作！
private:
    std::unique_ptr<int[]> data;  // 自动管理资源
};

默认和删除操作：
使用 = default 或 = delete 显式控制生成。

class AutoResourceHolder {
public:
    AutoResourceHolder(int size) : data(new int[size]) {}
    ~AutoResourceHolder() = default;

    // 显式生成移动操作，禁止拷贝
    AutoResourceHolder(AutoResourceHolder&&) = default;
    AutoResourceHolder& operator=(AutoResourceHolder&&) = default;
    AutoResourceHolder(const AutoResourceHolder&) = delete;
    AutoResourceHolder& operator=(const AutoResourceHolder&) = delete;

private:
    int* data;
};

http://www.kler.cn/a/612745.html

相关文章：

  • 127. 单词接龙【 力扣(LeetCode) 】
  • T11 TensorFlow入门实战——优化器对比实验
  • 谈谈空间复杂度考量，特别是递归调用栈空间消耗？
  • HTTP 状态码与前端 try-catch 捕获关系
  • java八股文之企业场景
  • Oracle数据库数据编程SQL＜2.2 DDL 视图、序列＞
  • 小白工具PDF转换 PDF转图片 超便捷软件 文件格式转换 简单好用效率高
  • RabbitMQ 核心组件及功能详解
  • 信息隐藏技术
  • Flutter_学习记录_get_cli的使用
  • nginx代理前端请求
  • Spring Boot旅游管理系统
  • 基于python爬虫：requests+BeautifulSoup+MySQL/MongoDB（或：CSV、JSON等格式的文件）+...
  • thinkphp漏洞再现
  • 《C++ 基石：筑牢编程巅峰根基》
  • Dynamic WallPaper-壁纸动态-Mac电脑-4K超高清
  • node-red
  • Ant Design Vue 中的table表格高度塌陷，造成行与行不齐的问题
  • 日记：实际开发中git的常用命令
  • 搭建私人对外git空间