具有动态分配数组的类的 C++ 复制构造函数

Question

刚开始接触 C++（现在几天），我有 C 背景。

我有一个类，它主要包含一个指向 int 数组的指针，代码如下：

class Array
{
private:
    int * _arr;
    int _size;
public:
    Array();
    Array(int size);
    Array(const Array& obj);  // copy constructor
    ~Array();
    void readInValues();
    void mult(int num);
    void add(int num);
    void printArray();
};

_arr 是一个指向 int 数组的指针，当使用复制构造函数创建一个新实例时，我会在堆上创建一个新的 int 数组（我认为）。在复制构造函数中：

Array::Array( const Array & obj )
{
    _arr = new int[_size];

    for(int i=0;i<_size;i++)
        *_arr[i] = *obj._arr[i];
}

我要做的第一件事是为新数组分配内存（_size 是一种原始类型，因此据我所知会自动复制）。我想做的下一件事是使用循环复制数组本身。这部分编译失败，说非法间接。我不知道为什么......

Answer 1

这个：

Array::Array( const Array & obj )
{
    _arr = new int[_size];

    for(int i=0;i<_size;i++)
        *_arr[i] = *obj._arr[i];
}

可能是这样的：

Array::Array( const Array & obj )
    : _arr(obj._size ? new int[obj._size] : nullptr)
    , _size(obj._size)
{
    if (_arr)
        std::copy(obj._arr, obj._arr+_size, _arr);
}

特别注意初始化列表的使用。其他值得一提的：

1. 不要使用带有前导下划线的标识符。除了使代码阅读起来非常痛苦之外，您还可以快速发现自己使用了由实现保留的标识符。这里不是这种情况，但我敢打赌这不是故意的。

2. 您还需要一个赋值运算符来实现Rule of Three。值得庆幸的是，一个体面的复制构造函数使这变得微不足道。

3. 不要这样做任何。这就是为什么，在设计决策过程中痛哭流涕和咬牙切齿的情况下，过去多年的全能 C++ 标准委员会如此选择以std::vector<> 祝福我们。如果你这样做是为了学习，很好。您最终将了解到，一旦您接受标准库及其所有罪恶的乐趣，您需要多么少见。

如果这是一个学习练习，请恭喜并愉快地忽略上面的 (3)。对于 (2)，您现在可以使用 copy/swap idiom，因为您有一个合理的 copy-ctor：

Array& Array::operator =(Array obj) // value-param intentional
{
    std::swap(_arr, obj._arr);
    std::swap(_size, obj._size);
    return *this;
}

祝你好运。

Answer 2

_size 没有初始值，因为您在使用它之前没有将它作为参数传递或在其他任何地方初始化。

另外，不要这样做*_arr[i] = *obj._arr[i];

这没有意义，因为arr[i] 本身就是*(arr+i)。

做：

_arr[i] = obj._arr[i];

Answer 3

当你这样做时，你应该没问题

Array::Array( const Array & obj ):
    _size(obj._size) 
{
    _arr = new int[_size];

    for(int i=0;i<_size;i++)
        _arr[i] = obj._arr[i];
}

在第 2 行你得到初始化列表，阅读这个http://www.cprogramming.com/tutorial/initialization-lists-c++.html

关键是，当您编写自定义复制构造函数时，只有您明确表示要复制的内容才会被复制。复制构造函数将首先为所有成员调用默认初始化程序，除非您使用初始化程序值。

另外，也许是对性能的一点提示，您是否查看过 memcpy？ http://www.cplusplus.com/reference/cstring/memcpy/ 可能更高效 :D

我注意到的另一件事是您取消引用 *_arr[i]，它不是指针而是对值的引用。

编辑有人注意到我的更好实际上并没有更好。我改了。

Answer 4

_size 是原始类型被复制实际上是一个真实的陈述，但你没有指定完整的句子。
当您不声明复制构造函数时，默认实现将是这样的

Array::Array( const Array & obj )
{
    this._size = obj._size;
    this._arr = obj._arr;
}

这是您不想要的，因为复制的对象将共享 _arr 变量。
但是当您实现了复制构造函数时，您需要完全实现它。 在您的情况下，您没有使用_size 的值。因此它将是未定义的。

编译失败是因为*_arr[i] = *obj._arr[i];这行。您正在使用 *.只需使用_arr[i] = obj._arr[i]; 复制即可。

Answer 5

这是我的解决方案。也许会有所帮助。

Array.h

#pragma once
class Array {

public:

    Array();
    Array(int size);
    Array(const Array& src);
    Array operator=(const Array& rhs);
    ~Array();

    void readInValues();
    void mult(int num);
    void add(int num);
    void printArray();

private:
    int *_arr;
    int _size;

};

我在引用三个规则时添加了赋值运算符。它是 Array.cpp

#include "Array.h"

Array::Array()
    :_size(10) {

    _arr = new int[_size];
}

Array::Array(int size)
    : _size(size) {

    _arr = new int[_size];
}

Array::Array(const Array& src) {
    _size = src._size;
    _arr = new int[_size];

    for (int i = 0; i < _size; i++) {
        _arr[i] = src._arr[i];
    }
}

Array Array::operator=(const Array& rhs) {
    if (this == &rhs) {
        return (*this);
    }

    delete[] _arr;

    _size = rhs._size;
    _arr = new int[_size];

    for (int i = 0; i < _size; i++) {
        _arr[i] = rhs._arr[i];
    }
}

Array::~Array() {
    delete[] _arr;
}