C++；使用动态分配的数组复制类的构造函数 刚刚开始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数组的指针，当使用copy构造函数创建新实例时，我会在堆上创建一个新的int数组（我想）。在复制构造函数中：

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

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

Array:：Array（常量数组和obj）
{
_arr=新整数[_大小]；
for（int i=0；i
\u size
没有初始值，因为在使用它之前，您没有将其作为参数传递或在其他任何地方初始化

另外，不要做
*\u arr[i]=*obj.\u arr[i]；

它没有意义，因为
arr[i]
本身意味着
*（arr+i）

做：

\u size
没有初始值，因为在使用它之前，您既没有将其作为参数传递，也没有在其他任何地方初始化

另外，不要做
*\u arr[i]=*obj.\u arr[i]；

它没有意义，因为
arr[i]
本身意味着
*（arr+i）

做：

当你这么做的时候，你应该会没事的

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

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

Array:：Array（常量数组和obj）：
_尺寸（对象尺寸）
{
_arr=新整数[_大小]；
对于（inti=0；i当你这样做时，你应该很好

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

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

Array:：Array（常量数组和obj）：
_尺寸（对象尺寸）
{
_arr=新整数[_大小]；
对于（int i=0；i

具体来说，请注意初始值设定项列表的使用。其他值得一提的事项：

不要使用带有前导下划线的标识符。除了让代码成为阅读的难点之外，您还可以很快发现自己正在使用由实现保留的标识符。这里不是这样，但我敢打赌这不是故意的

您还需要一个赋值运算符来完成这个任务。谢天谢地，一个像样的复制构造函数使得这个任务变得微不足道

这就是为什么，在设计决定中，我们都会大哭和咬牙切齿，过去的几年来，全能的C++标准委员会已经选择了祝福我们。如果你这么做是为了学习，那么你最终会学到的是，一旦你接受标准库和它的所有罪过，你是多么难得。措施

如果这是一个学习练习，那么请忽略上面的第（3）项。对于第（2）项，您可以使用现在您有了一个合理的副本：

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

祝你好运。
这是：

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

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

具体来说，请注意初始值设定项列表的使用。其他值得一提的事项：

不要使用带有前导下划线的标识符。除了让代码成为阅读的难点之外，您还可以很快发现自己正在使用由实现保留的标识符。这里不是这样，但我敢打赌这不是故意的

您还需要一个赋值运算符来完成这个任务。谢天谢地，一个像样的复制构造函数使得这个任务变得微不足道

这就是为什么，在设计决定中，我们都会大哭和咬牙切齿，过去的几年来，全能的C++标准委员会已经选择了祝福我们。如果你这么做是为了学习，那么你最终会学到的是，一旦你接受标准库和它的所有罪过，你是多么难得。措施

如果这是一个学习练习，那么请忽略上面的第（3）项。对于第（2）项，您可以使用现在您有了一个合理的副本：

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

祝你好运。
\u要复制的原语类型的大小实际上是一个正确的语句，但你没有指定完整的句子。

当您不声明副本构造函数时，默认实现如下

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

这是您不想要的，因为复制的对象将共享\u arr变量。

但是，由于您已经实现了复制构造函数，因此需要完全实现它。
在您的情况下，您没有使用
\u size
的值。因此它将是未定义的

编译失败是由于行
*\u arr[i]=*obj.\u arr[i]
造成的。您正在使用*使用非法间接寻址。只需使用
\u arr[i]=obj.\u arr[i]
复制它。
\u正在复制的原语类型的大小实际上是一个true语句，但您没有指定完整的句子。

当您不声明副本构造函数时，默认实现如下

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

这是您不想要的，因为复制的对象将共享\u arr变量。

但是，由于您已经实现了复制构造函数，因此需要完全实现它。
在您的情况下，您没有使用
\u size
的值。因此它将是未定义的

编译失败是由于行
*\u arr[i]=*obj.\u arr[i]；
造成的。您正在使用*使用非法间接寻址。只需使用
\u arr[i]=obj.\u arr[i]；
复制它。
这是我的解决方案。也许会有所帮助

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;
}

#包括“Array.h”
数组：：数组（）
：_尺寸（10）{
_arr=新整数[_大小]；
}
数组：：数组（整数大小）
：_尺寸（尺寸）{
_arr=新整数[_大小]；
}
数组：：数组（常量数组和src）{
_尺寸=src.\u尺寸；
_arr=新整数[_大小]；
对于（int i=0；i<\u size；i++）{
_arr[i]=src.u arr[i]；
}
}
数组：：运算符=（常量数组和rhs）{
如果（此==&rhs）{
返回（*本条）；
}
删除[]_arr；
_尺寸=rhs.\u尺寸；
_arr=新整数[_大小]；
对于（int i=0；i<\u size；i++）{
_arr[i]=rhs._arr[i]；
}
}
数组：：~Array（）{
删除[]_arr；
}
这是我的解决方案。也许会有帮助

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;
}

#包括“Array.h”
数组：：数组（）
：_尺寸（10）{
_arr=新整数[_大小]；
}
数组：：数组（整数大小）
：_尺寸（尺寸）{
_arr=新整数[_大小]；
}
数组：：数组（常量数组和src）{
_尺寸=src.\u尺寸；
_arr=新整数[\u大小]