关于c ++：动态分配对象数组

Dynamically allocating an array of objects

这是一个初学者的问题，但是我很久没有做C++了，所以这里…

我有一个类，它包含一个动态分配的数组，比如

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class A
{
int* myArray;
A()
{
myArray = 0;
}
A(int size)
{
myArray = new int[size];
}
~A()
{
// Note that as per MikeB's helpful style critique, no need to check against 0.
delete [] myArray;
}
}

但是现在我想创建一个动态分配的这些类的数组。这是我的当前代码：

1
2
3
4
5

A* arrayOfAs = new A[5];
for (int i = 0; i < 5; ++i)
{
arrayOfAs[i] = A(3);
}

但这件事搞得糟透了。因为创建的新A对象(使用A(3)调用)在for循环迭代完成时被销毁，这意味着该A实例的内部myArray得到delete []ed。

所以我想我的语法一定是错的。我想有一些修复方法看起来像是过度杀戮，我希望避免：

为A创建复制构造函数。
使用vector和vector，所以我不必担心这一切。

不是让arrayOfAs是A对象的数组，而是让它是A*指针的数组。

我认为这只是一些初学者的事情，在尝试动态分配具有内部动态分配的事物数组时，实际上有一个语法可以工作。

(风格批评也很受欢迎，因为我做C++已经有一段时间了。)

为未来的观众更新：下面的所有答案都非常有用。因为示例代码和有用的"规则4"，马丁被接受了，但我真的建议把它们都读一遍。有些是关于错误的好的、简洁的陈述，有些则正确地指出了vector是一种好的方式，以及为什么它是一种好的方式。

对于构建容器，您显然希望使用一个标准容器(例如std:：vector)。但这是一个完美的例子，说明当对象包含原始指针时需要考虑的事情。

如果你的对象有一个原始指针，那么你需要记住3的规则(现在是C++ 11中的5条规则)。

构造函数
析构函数
复制构造函数
分配运算符
移动构造函数(C++ 11)
移动赋值(C++ 11)

这是因为如果没有定义编译器将生成这些方法的自己版本(见下文)。处理原始指针时，编译器生成的版本并不总是有用的。

复制构造函数是很难得到正确答案的(如果您想提供强异常保证，这是非常重要的)。可以使用复制构造函数定义赋值运算符，因为您可以在内部使用复制和交换习惯用法。

有关包含指向整数数组的指针的类的绝对最小值的完整详细信息，请参阅下面。

要知道纠正它是非常重要的，您应该考虑使用std：：vector，而不是指向整数数组的指针。向量易于使用(和扩展)，并涵盖与异常相关的所有问题。将下面的类与下面的定义进行比较。

1
2
3
4
5
6
7

class A
{
std::vector<int> mArray;
public:
A(){}
A(size_t s) :mArray(s) {}
};

看看你的问题：

1
2
3
4
5
6
7
8
9
10
11
12
13

A* arrayOfAs = new A[5];
for (int i = 0; i < 5; ++i)
{
// As you surmised the problem is on this line.
arrayOfAs[i] = A(3);

// What is happening:
// 1) A(3) Build your A object (fine)
// 2) A::operator=(A const&) is called to assign the value
// onto the result of the array access. Because you did
// not define this operator the compiler generated one is
// used.
}

编译器生成的赋值运算符几乎适用于所有情况，但当使用原始指针时，需要注意。在您的情况下，这是由于浅复制问题导致的问题。您最终得到了两个包含指向同一内存块的指针的对象。当a(3)在循环结束时超出作用域时，它在其指针上调用delete[]。因此，另一个对象(在数组中)现在包含一个指向已返回到系统的内存的指针。

编译器生成复制构造函数；使用该成员复制构造函数复制每个成员变量。对于指针，这意味着指针值从源对象复制到目标对象(因此是浅复制)。

编译器生成的赋值运算符；使用该成员赋值运算符复制每个成员变量。对于指针，这意味着指针值从源对象复制到目标对象(因此是浅复制)。

所以包含指针的类的最小值是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

class A
{
size_t mSize;
int* mArray;
public:
// Simple constructor/destructor are obvious.
A(size_t s = 0) {mSize=s;mArray = new int[mSize];}
~A() {delete [] mArray;}

// Copy constructor needs more work
A(A const& copy)
{
mSize = copy.mSize;
mArray = new int[copy.mSize];

// Don't need to worry about copying integers.
// But if the object has a copy constructor then
// it would also need to worry about throws from the copy constructor.
std::copy(&copy.mArray[0],&copy.mArray[c.mSize],mArray);

}

// Define assignment operator in terms of the copy constructor
// Modified: There is a slight twist to the copy swap idiom, that you can
// Remove the manual copy made by passing the rhs by value thus
// providing an implicit copy generated by the compiler.
A& operator=(A rhs) // Pass by value (thus generating a copy)
{
rhs.swap(*this); // Now swap data with the copy.
// The rhs parameter will delete the array when it
// goes out of scope at the end of the function
return *this;
}
void swap(A& s) noexcept
{
using std::swap;
swap(this.mArray,s.mArray);
swap(this.mSize ,s.mSize);
}

// C++11
A(A&& src) noexcept
: mSize(0)
, mArray(NULL)
{
src.swap(*this);
}
A& operator=(A&& src) noexcept
{
src.swap(*this); // You are moving the state of the src object
// into this one. The state of the src object
// after the move must be valid but indeterminate.
//
// The easiest way to do this is to swap the states
// of the two objects.
//
// Note: Doing any operation on src after a move
// is risky (apart from destroy) until you put it
// into a specific state. Your object should have
// appropriate methods for this.
//
// Example: Assignment (operator = should work).
// std::vector() has clear() which sets
// a specific state without needing to
// know the current state.
return *this;
}
}