C++类如果没有重载赋值运算符会发生什么即默认赋值行为

在C++中，如果一个类没有显式重载赋值运算符（operator=），编译器会为该类生成一个默认的赋值运算符。这个默认的赋值运算符的行为取决于类的成员变量类型。以下是具体的情况和可能的影响：

---

1. 默认赋值运算符的行为

默认的赋值运算符会逐个成员地进行浅拷贝（shallow copy）：

• 对于基本类型（如int、double等），直接复制值。

• 对于类类型的成员变量，调用该类的赋值运算符。

• 对于指针类型的成员变量，仅复制指针的值（即地址），而不会复制指针指向的内容。

示例：

class MyClass {
public:
    int a;
    double b;
    std::string s;
};

MyClass obj1;
obj1.a = 10;
obj1.b = 3.14;
obj1.s = "Hello";

MyClass obj2;
obj2 = obj1; // 使用默认的赋值运算符

在上面的例子中，obj2的成员变量会逐字节复制obj1的值。

---

2. 默认赋值运算符的问题

默认的赋值运算符在以下情况下可能会导致问题：

（1）指针成员变量

如果类中有指针成员变量，默认的赋值运算符只会复制指针的值（浅拷贝），而不会复制指针指向的内容。这会导致以下问题：

• 内存泄漏：原有指针指向的内存未被释放。

• 双重释放：多个对象指向同一块内存，析构时会导致重复释放。

• 悬空指针：一个对象释放内存后，另一个对象仍然持有指向该内存的指针。

示例：

class BadClass {
public:
    int* data;

    BadClass() : data(new int[100]) {}
    ~BadClass() { delete[] data; }
};

BadClass obj1;
BadClass obj2;
obj2 = obj1; // 默认赋值运算符：浅拷贝指针

问题：

• obj1和obj2的data指针指向同一块内存。

• 当obj1和obj2析构时，会重复释放同一块内存，导致未定义行为。

（2）资源管理类

如果类管理其他资源（如文件句柄、网络连接等），默认的赋值运算符可能会导致资源泄漏或重复释放。

---

3. 如何避免默认赋值运算符的问题

为了避免默认赋值运算符的问题，可以采取以下措施：

（1）显式重载赋值运算符

为类显式实现赋值运算符，确保正确管理资源。

class GoodClass {
public:
    int* data;

    GoodClass() : data(new int[100]) {}
    ~GoodClass() { delete[] data; }

    // 重载赋值运算符
    GoodClass& operator=(const GoodClass& other) {
        if (this != &other) { // 检查自赋值
            delete[] data; // 释放原有资源
            data = new int[100]; // 分配新资源
            std::copy(other.data, other.data + 100, data); // 复制数据
        }
        return *this;
    }
};

（2）使用拷贝-交换惯用法

通过拷贝构造函数和交换函数实现赋值运算符，提高代码的异常安全性和简洁性。

class GoodClass {
public:
    int* data;

    GoodClass() : data(new int[100]) {}
    ~GoodClass() { delete[] data; }

    // 拷贝构造函数
    GoodClass(const GoodClass& other) : data(new int[100]) {
        std::copy(other.data, other.data + 100, data);
    }

    // 赋值运算符（拷贝-交换惯用法）
    GoodClass& operator=(GoodClass other) {
        swap(*this, other);
        return *this;
    }

    // 交换函数
    friend void swap(GoodClass& first, GoodClass& second) noexcept {
        std::swap(first.data, second.data);
    }
};

（3）禁用赋值运算符

如果类不应该支持赋值操作，可以将赋值运算符声明为delete。

class NonCopyableClass {
public:
    NonCopyableClass() = default;
    NonCopyableClass& operator=(const NonCopyableClass&) = delete;
};

---

4. 总结

• 如果一个类没有显式重载赋值运算符，编译器会生成一个默认的赋值运算符，执行逐成员的浅拷贝。

• 默认赋值运算符在处理指针或资源管理类时可能会导致内存泄漏、双重释放或悬空指针等问题。

• 为了避免这些问题，可以：

  1. 显式重载赋值运算符。

  2. 使用拷贝-交换惯用法。

  3. 禁用赋值运算符（如果不希望类支持赋值操作）。