动态分配对象数组

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

如果你的对象有一个RAW指针，那么你需要记住3的规则（现在是C++11中的5的规则）。

• 施工单位
• 破坏者
• 复制构造函数
• 分配运算符
• 移动构造函数（C++11）
• 移动分配（C++11）

这是因为如果没有定义，编译器将生成这些方法的自己版本（见下文）。编译器生成的版本在处理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(&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;
         }   
 }

我建议使用std:：vector：类似的东西

typedef std::vector<int> A;
typedef std::vector<A> AS;

STL的过度使用没有错，你可以花更多的时间来实现应用程序的特定功能，而不是重新设计自行车。

A对象的构造函数动态分配另一个对象，并将指向该动态分配对象的指针存储在原始指针中。

对于该场景，必须定义自己的复制构造函数、赋值运算符和析构函数。编译器生成的将无法正常工作。（这是"三大定律"的必然结果：一个具有析构函数、赋值运算符和复制构造函数中任意一个的类通常需要全部3个）。

您已经定义了自己的析构函数（并且提到创建了一个复制构造函数），但您需要同时定义三大析构函数中的其他两个。

另一种选择是将指向动态分配的int[]的指针存储在其他对象中，该对象将为您处理这些事情。像vector<int>（正如你提到的）或boost::shared_array<>之类的东西。

简而言之，为了充分利用RAII，您应该尽可能避免处理原始指针。

由于您询问了其他风格批评，一个次要的问题是，当您删除原始指针时，在调用delete之前不需要检查0——delete通过不做任何事情来处理这种情况，这样您就不必用检查来打乱代码。

1. 只有当对象具有默认构造函数和复制构造函数时，才对其使用数组或公共容器。

2. 以其他方式存储指针（或智能指针，但在这种情况下可能会遇到一些问题）。

PS：始终定义自己的默认和复制构造函数，否则将使用自动生成的

您需要一个赋值运算符，以便：

arrayOfAs[i] = A(3);

工作正常。

为什么不使用setSize方法。

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

我喜欢"副本"，但在这种情况下，默认构造函数实际上并没有做任何事情。SetSize可以从原始m_array（如果存在）中复制数据。。要做到这一点，您必须将数组的大小存储在类中
或
SetSize可以删除原始m_array。

void SetSize(unsigned int p_newSize)
{
    //I don't care if it's null because delete is smart enough to deal with that.
    delete myArray;
    myArray = new int[p_newSize];
    ASSERT(myArray);
}

使用new运算符的放置功能，您可以在适当的位置创建对象并避免复制：

placement（3）:void*operator new（std:：size_t size，void*ptr）noexcept；

只需返回ptr（没有分配存储）。请注意，如果函数由新表达式调用，则将执行正确的初始化（对于类对象，这包括调用其默认构造函数）。

我建议如下：

A* arrayOfAs = new A[5]; //Allocate a block of memory for 5 objects
for (int i = 0; i < 5; ++i)
{
    //Do not allocate memory,
    //initialize an object in memory address provided by the pointer
    new (&arrayOfAs[i]) A(3);
}