对于构建容器，您显然希望使用标准容器之一（例如 std::vector）。但这是当您的对象包含 RAW 指针时您需要考虑的事情的一个完美示例。
如果您的对象有一个 RAW 指针，那么您需要记住规则 3（现在是 C++11 中的 5 规则）。
- 构造函数
- 析构函数
- 复制构造函数
- 赋值运算符
- 移动构造函数 (C++11)
- 移动赋值 (C++11)
这是因为如果未定义，编译器将生成自己的这些方法版本（见下文）。编译器生成的版本在处理 RAW 指针时并不总是有用。
复制构造函数是很难正确的（如果你想提供强大的异常保证，这很重要）。赋值运算符可以根据复制构造函数定义，因为您可以在内部使用复制和交换习语。
有关包含指向整数数组的指针的类的绝对最小值的完整详细信息，请参见下文。
知道要使其正确并非易事，您应该考虑使用 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;
}
}