探索C++世界：深度解析类与对象的拷贝机制及运算符重载实践

安大小万

已于 2024-04-16 22:16:12 修改

阅读量924

点赞数 24

分类专栏： C++ 文章标签： c++

于 2024-04-16 22:15:28 首次发布

本文链接：https://blog.csdn.net/wgr050505/article/details/137842593

版权

C++ 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

本文详细介绍了C++中拷贝构造函数和赋值运算符的默认行为、自定义实现以及在处理动态资源时的重要性。通过实例演示了如何避免浅拷贝陷阱，实现深拷贝，并重载各种运算符以优化对象行为。

摘要由CSDN通过智能技术生成

4. 除法运算符 / 的重载（这里以分数类为例）：

5. 加法赋值运算符 += 的重载：

6. 前缀递增运算符 ++ 的重载：

结语

导语

在C++编程的世界里，类与对象的生命周期管理和资源控制是一项核心技能，而这其中拷贝函数和运算符重载扮演着至关重要的角色。本文将带你深入探讨C++中的拷贝构造函数和赋值运算符重载，揭示默认行为背后的秘密，并通过丰富的代码示例展示如何编写高效安全的自定义版本。

第一部分：拷贝构造函数的魅力

默认拷贝构造函数的运作原理

每当创建一个对象作为另一个对象的副本时，拷贝构造函数便会被调用。C++编译器为每个类自动提供了一个默认的拷贝构造函数，其功能是对所有非静态成员进行逐个浅拷贝。这意味着对于基本类型成员，直接复制值；而对于指针或其他容器型成员，则仅复制指针本身，而不复制指针所指向的数据。

class SimpleClass {
public:
    int value;
    SimpleClass(int v) : value(v) {} // 构造函数
};

SimpleClass obj1(10);
SimpleClass obj2(obj1); // 使用默认拷贝构造函数，obj2.value 也将为10

然而，当类包含动态分配的内存或资源时，这种默认拷贝会导致问题，因为浅拷贝只会复制指针，导致两个对象指向同一块内存，形成所谓的“浅拷贝陷阱”。

自定义拷贝构造函数及其应用场景

为了正确地复制含有动态资源的对象，我们需要编写自定义的拷贝构造函数，执行深拷贝：

class DeepCopyClass {
private:
    int* data;
public:
    DeepCopyClass(int val) : data(new int(val)) {}
    // 自定义拷贝构造函数，执行深拷贝
    DeepCopyClass(const DeepCopyClass& other) : data(new int(*other.data)) {}
    ~DeepCopyClass() { delete data; } // 释放资源
};

DeepCopyClass deep1(100);
DeepCopyClass deep2(deep1); // 此时，deep2.data 指向与 deep1 不同的新分配的内存空间

第二部分：赋值运算符重载的艺术

默认赋值运算符的局限性

默认赋值运算符同样执行浅拷贝操作，它适用于简单类，但对于含有指针或其他资源的类，也存在同样的浅拷贝问题。

class DefaultAssignClass {
public:
    int* ptr;
    DefaultAssignClass(int val) : ptr(new int(val)) {}
    // 缺少自定义赋值运算符，此处为默认浅拷贝赋值
};
DefaultAssignClass assign1(200);
DefaultAssignClass assign2;
assign2 = assign1; // 使用默认赋值运算符，此时两者ptr指向同一地址

自定义赋值运算符重载实例

为了解决这个问题，我们可以通过重载赋值运算符实现深拷贝，并考虑自我赋值的情况，同时确保资源的正确释放：

class CustomAssignClass {
private:
    int* data;
public:
    CustomAssignClass(int val) : data(new int(val)) {}
    CustomAssignClass& operator=(const CustomAssignClass& other) {
        if (this != &other) { // 避免自我赋值
            delete data;
            data = new int(*other.data);
        }
        return *this; // 支持连续赋值
    }
    ~CustomAssignClass() { delete data; }
};

CustomAssignClass custom1(300);
CustomAssignClass custom2;
custom2 = custom1; // 现在custom2.data指向独立分配的内存

1. 加法运算符 `+` 的重载：

class Complex {
public:
    double real, imaginary;

    Complex(double r = 0.0, double i = 0.0) : real(r), imaginary(i) {}

    // 重载加法运算符
    Complex operator+(const Complex& other) const {
        Complex result;
        result.real = this->real + other.real;
        result.imaginary = this->imaginary + other.imaginary;
        return result;
    }
};

int main() {
    Complex c1(3.0, 4.0);
    Complex c2(1.0, 2.0);
    Complex c3 = c1 + c2;
    // c3 现在表示的是 (4.0 + 6.0i)
}

2. 减法运算符 `-` 的重载：

class Vector2D {
public:
    float x, y;

    Vector2D(float _x, float _y) : x(_x), y(_y) {}

    // 重载减法运算符
    Vector2D operator-(const Vector2D& other) const {
        Vector2D result;
        result.x = this->x - other.x;
        result.y = this->y - other.y;
        return result;
    }
};

int main() {
    Vector2D v1(3.0f, 4.0f);
    Vector2D v2(1.0f, 2.0f);
    Vector2D v3 = v1 - v2;
    // v3 现在表示的是 (2.0, 2.0)
}

3. 乘法运算符 `*` 的重载：

class Matrix {
    // 假设Matrix类已经实现了矩阵元素存储和访问...
public:
    Matrix operator*(const Matrix& other) const {
        // 实现矩阵乘法算法
        Matrix result(size());
        // ...计算result矩阵
        return result;
    }
};

int main() {
    Matrix m1, m2, m3;
    // ...填充m1和m2
    m3 = m1 * m2;
    // m3现在是m1和m2的乘积
}

4. 除法运算符 `/` 的重载（这里以分数类为例）：

class Rational {
private:
    int numerator, denominator;
    
public:
    Rational(int n, int d) : numerator(n), denominator(d) {}

    // 重载除法运算符
    Rational operator/(const Rational& other) const {
        int lcm = findLCM(this->denominator, other.denominator); // 找到两个分母的最小公倍数
        return Rational(this->numerator * (lcm / this->denominator),
                       other.numerator * (lcm / other.denominator));
    }

    // 省略findLCM函数实现...
};

int main() {
    Rational r1(3, 4);
    Rational r2(2, 5);
    Rational r3 = r1 / r2;
    // r3现在表示的是 (15/20)，简化后为 (3/4)
}

5. 加法赋值运算符 `+=` 的重载：

class BigInt {
private:
    // 假设BigInt内部已经实现大整数的存储和操作...

public:
    // 重载加法赋值运算符
    BigInt& operator+=(const BigInt& other) {
        // 实现加法算法并将结果存储到*this中
        // ...
        return *this;
    }
};

int main() {
    BigInt big1, big2, big3;
    // ...填充big1和big2
    big1 += big2;
    // big1现在增加了big2的值
}

6. 前缀递增运算符 `++` 的重载：

class Counter {
private:
    int count;

public:
    Counter(int initValue = 0) : count(initValue) {}

    // 重载前缀递增运算符
    Counter& operator++() {
        ++count;
        return *this;
    }
};

int main() {
    Counter c(10);
    ++c;
    // c现在计数值为11
}

结语

理解并熟练掌握拷贝构造函数和赋值运算符重载是提升C++编程技巧的关键步骤。实践中，不仅要注意对类内资源的正确管理，还要遵循RAII原则（Resource Acquisition Is Initialization），确保资源在合适的时间得到正确的创建和销毁。通过自定义这些拷贝机制，程序员能够更好地掌控对象的行为，提高程序的安全性和效率。