C++ 类与对象：运算符重载、赋值与取址详解

运行结果会显示不相等。这里的关键在于，虽然代码写的是 d1 == d2，但在底层汇编层面，它已经被编译器自动转换成了 d1.operator==(d2)。这种透明性让我们能像使用内置类型一样使用自定义类型。

注意：不能重载内置类型运算符。尝试对 int 进行重载会导致编译错误，因为至少需要一个操作数是类类型。

二、赋值重载

赋值重载也是类的默认成员函数之一。如果不手动编写，编译器会生成一个默认的赋值函数。理解它的行为以及何时需要自己实现，是掌握类机制的关键。

默认生成的赋值重载行为

对于内置类型，默认赋值函数执行浅拷贝，即按字节复制。对于自定义类型，它会递归调用成员变量的赋值函数。这意味着如果类中包含指针成员，默认行为可能导致两个对象共享同一块堆内存，析构时引发重复释放错误。

判断是否需要手动实现赋值重载，可以参考以下技巧：

1. 看析构/拷贝构造：如果写了析构函数或拷贝构造，通常意味着涉及资源管理，此时应配套实现赋值重载。
2. 看堆空间：检查是否有内置类型成员变量指向堆空间（如 int*）。如果有，必须手动深拷贝。

手动实现赋值重载

以栈类（Stack）为例，它包含动态分配的数组。如果依赖默认赋值，两个栈对象将指向同一内存，修改一个会影响另一个，且析构时会崩溃。

我们需要手动实现深拷贝，并遵循以下原则：

1. 成员函数：赋值运算符必须重载为成员函数。
2. 参数引用：参数建议使用 const 引用，避免拷贝并防止权限放大。
3. 返回值：返回当前对象的引用（*this），以支持连续赋值（如 a = b = c）。
4. 自赋值检查：必须检查 this != &other，防止给自己赋值导致内存泄漏或数据覆盖。

class Stack {
public:
    Stack(int n = 10) {
        this->_arr = (int*)malloc(n * sizeof(int));
        if (this->_arr == nullptr) {
            perror("malloc");
            return;
        }
        this->_top = 0;
        this->_capacity = n;
    }

    ~Stack() {
        if (this->_arr) free(this->_arr);
        this->_top = this->_capacity = 0;
    }

    // 拷贝构造
    Stack(const Stack& st) {
        this->_arr = (int*)malloc(st._capacity * sizeof(int));
        for (int i = 0; i < st._top; i++) {
            this->_arr[i] = st._arr[i];
        }
        this->_top = st._top;
        this->_capacity = st._capacity;
    }

    // 赋值重载
    Stack& operator=(const Stack& st) {
        if (this != &st) { // 自赋值检查
            free(this->_arr); // 先释放原有资源
            this->_arr = (int*)malloc(st._capacity * sizeof(int));
            for (int i = 0; i < st._top; i++) {
                this->_arr[i] = st._arr[i];
            }
            this->_top = st._top;
            this->_capacity = st._capacity;
        }
        return *this;
    }

    void push(int x) {
        this->_arr[this->_top++] = x;
    }

private:
    int* _arr;
    int _top;
    int _capacity;
};

int main() {
    Stack st1;
    st1.push(2);
    st1.push(3);
    Stack st2;
    st2 = st1; // 调用赋值重载
    return 0;
}

区分拷贝构造与赋值重载

两者容易混淆，核心区别在于对象是否已存在：

• 拷贝构造：对象正在被创建，用另一个对象初始化。例如 Date d2(d1); 或 Date d2 = d1;（注意：这里的 = 是初始化，不是赋值）。
• 赋值重载：对象已存在，将值赋给现有对象。例如 d2 = d1;。

调试时可以通过断点观察调用时机来确认。

三、取地址重载

取地址运算符 (&) 分为普通版本和 const 版本。编译器默认生成的版本足够日常使用，但在特殊场景下，我们可以自定义它们来控制访问权限。

例如，如果不想让外部轻易获取对象地址，可以返回空指针或特定地址。这常用于封装安全控制。

class Stack {
public:
    // 普通取地址重载
    Stack* operator&() {
        return nullptr; // 拒绝获取地址
    }

    // const 取地址重载
    Stack* operator&() const {
        return nullptr;
    }
};

int main() {
    Stack st1;
    Stack* ps = &st1; // 调用重载函数，ps 为 nullptr
    return 0;
}

运行后会发现无法获取有效地址。除非有特殊的安全需求，否则建议直接使用编译器默认生成的版本。