动态分配一个对象数组
这是一个初学者的问题，但我很久没有做C ++了，所以这里...
我有一个包含动态分配数组的类，比如说
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;
}
}
但是现在我想创建一个动态分配的这些类的数组。 这是我现在的代码：
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<int>和vector<A>所以我不必担心所有这些。 arrayOfAs作为A对象的数组，而不是将它作为A*指针的数组。 我认为这只是一些初学者的事情，当尝试动态分配一系列具有内部动态分配的事物时，有一种实际工作的语法。
（另外，风格批评也很受赞赏，因为自从我做C ++以来已经有一段时间了。）
未来观众更新 ：以下所有答案都非常有用。 由于示例代码和有用的“4规则”，Martin's被接受，但我真的建议阅读它们。 有些是好的，简洁的声明是错误的，有些正确地指出了vector如何以及为什么是一个好的方法。
对于构建容器，您显然希望使用其中一个标准容器（如std :: vector）。 但是当你的对象包含RAW指针时，这是你需要考虑的事情的完美例子。
如果你的对象有一个RAW指针，那么你需要记住3的规则（现在是C ++ 11中的5的规则）。
这是因为如果没有定义，编译器将生成它自己的这些方法（见下文）。 编译器生成的版本在处理RAW指针时并不总是有用的。
复制构造函数是难以得到正确的（如果你想提供强大的异常保证，这是不重要的）。 Assignment操作符可以根据Copy构造函数定义，因为您可以在内部使用复制和交换习语。
有关包含指向整数数组的指针的类的绝对最小值，请参阅下面的全部细节。
知道它是正确的，你应该考虑使用std :: vector而不是指向整数数组的指针。 该向量易于使用（并扩展）并涵盖与例外相关的所有问题。 将下面的类与下面的A的定义进行比较。
class A
{
std::vector<int> mArray;
public:
A(){}
A(size_t s) :mArray(s) {}
};
看看你的问题：
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.
}
编译器生成的赋值运算符几乎适用于所有情况，但是当RAW指针处于运行状态时，您需要注意。 在你的情况下，由于浅拷贝问题导致问题。 你已经结束了两个包含指向同一块内存的指针的对象。 当A（3）在循环结束时超出范围时，它会在其指针上调用delete []。 因此，另一个对象（在数组中）现在包含一个指向已被返回到系统的内存的指针。
编译器生成拷贝构造函数; 通过使用该成员复制构造函数来复制每个成员变量。 对于指针而言，这仅仅意味着指针值从源对象复制到目标对象（因此是浅拷贝）。
编译器生成赋值运算符; 通过使用该成员赋值运算符来复制每个成员变量。 对于指针而言，这仅仅意味着指针值从源对象复制到目标对象（因此是浅拷贝）。
所以包含一个指针的类的最小值：
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(©.mArray[0],©.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;
}
}
我建议使用std :: vector：类似
typedef std::vector<int> A;
typedef std::vector<A> AS;
STL的轻微矫枉过正没有任何问题，您可以花更多时间来实现应用程序的特定功能，而不是重新发明自行车。
A对象的构造函数动态分配另一个对象，并将指针存储在原始指针中的动态分配对象。
对于这种情况，您必须定义您自己的副本构造函数，赋值运算符和析构函数。 编译器生成的将无法正常工作。 （这是“三巨头法则”的必然结果：具有任何析构函数，赋值运算符，拷贝构造函数的类通常都需要3）。
你已经定义了你自己的析构函数（并且你提到了创建一个拷贝构造函数），但是你需要定义其他两个大三。
另一种方法是将指针存储到其他对象中的动态分配的int[] ，以便为您处理这些事情。 就像vector<int> （如你所说）或boost::shared_array<> 。
为了解决这个问题 - 充分利用RAII，应尽可能避免处理原始指针。
既然你问其他风格的批评，未成年人一个是，当你正在删除原始指针你不需要调用之前检查0 delete - delete无为而处理这种情况下，这样你就不必扰乱你的代码检查。