为具有指针成员的类正确重载赋值运算符

Question

如我错了请纠正我：

我知道当一个类的成员是指针时，类对象的副本将导致指针表示相同的内存地址。这可能导致对一个类对象进行更改以影响该对象的所有副本。

解决此问题的方法是重载 = 运算符。给定下面的示例，尝试创建一个动态数组类，为什么对 MyArray1 进行更改会更改 MyArray2 ：

数组类：

 #include <iostream>
#include <cstdlib>

class Array
{
public:
    Array(int N){               //constructor sets size of array
         size = N;
         arr = new int[N];
    }

    ~Array();

    int size;    //array elements
    int *arr;    //dynamic array pointer

    //fill array with random values between 1 and 100
    void fillArray() {
         for (size_t i = 0; i < size; i++)
              {arr[i] = std::rand()%100;}
    }

    //print out array to console
    void printArray() {
         for (size_t i = 0; i < size; i++)
             { std::cout << arr[i] << " ";}
             std::cout << std::endl;
    }

    //overload = operator
    Array &operator=(Array arr2) {
        std::swap(size, arr2.size);
        std::swap(arr, arr2.arr);
        return *this;
    }
};

主要.cpp：

  #include "Array.h"
 #include <iostream>

int main(){
    Array MyArray1(8), MyArray2(8);

    MyArray1.fillArray();
    MyArray2 = MyArray1;

    std::cout << "Print out arrays:" << std::endl;
    std::cout << "MyArray1: "; MyArray1.printArray();
    std::cout << "MyArray2: "; MyArray2.printArray();
    std::cout << std::endl;

    MyArray1.arr[5] = 1000;
    std::cout << "MyArray2: "; MyArray2.printArray();

    MyArray1.fillArray();
    std::cout << "MyArray2: "; MyArray2.printArray();

    return 0;
}

示例输出：

 Print out arrays:
MyArray1: 41 67 34 0 69 24 78 58
MyArray2: 41 67 34 0 69 24 78 58

MyArray2: 41 67 34 0 69 1000 78 58
MyArray2: 62 64 5 45 81 27 61 91

如上所示，对 MyArray1 所做的更改会更改 MyArray2。我认为 = 的重载是错误的，但我该如何正确编写它？

解决方案：

感谢评论中的 Chris Dodd，我意识到这只是在我的类中实现这样的复制构造函数：

 Array(const Array &arr2){
        size = arr2.size;
        arr = new int[size];

        for (size_t i = 0; i < size; i++)
        {
            arr[i] = arr2.arr[i];
        }
}

原文由 remi 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 1

您的代码存在不止一个问题。最重要的是，正如对该问题的评论中所指出的，除了编写自己的赋值运算符之外，您还需要编写复制构造函数（并实现析构函数）。

第二件事是，您的赋值运算符按值而不是按引用获取参数，这会导致默认复制构造函数在传递给赋值运算符之前创建 MyArray1 的副本。这就是问题的直接根源所在。

另一件事是您的赋值运算符的行为类似于移动赋值而不是复制赋值，这意味着它将原始项目的值替换为其当前（默认）值。

最后，您真的想实现析构函数，以便它删除您的数组，而不是仅仅泄漏它。

总而言之，你想要这样的东西（编辑：受蒂莫西回答启发的复制分配检查）：

 class Array
{
public:
    Array(int N)
    {
         size = N;
         arr = new int[N];
    }

    //destructor
    ~Array()
    {
        delete[] arr;
    }

    //copy constructor
    Array(const Array& arr2)
    {
        size = arr2.size;
        arr = new int[size];
        std::memcpy(arr, arr2.arr, size);
    }

    //overload = operator
    Array& operator=(const Array& arr2)
    {
        if (this == &arr2)
            return *this; //self assignment
        if (arr != NULL)
            delete[] arr; //clean up already allocated memory

        size = arr2.size;
        arr = new int[size];
        std::memcpy(arr, arr2.arr, size);
        return *this;
    }

private:
    int size;    //array elements
    int *arr;    //dynamic array pointer
};

原文由 slawekwin 发布，翻译遵循 CC BY-SA 3.0 许可协议