动态分配对象数组-解网

问：

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

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

但这非常可怕。因为创建的新对象（使用调用）在循环迭代完成时被析构，这意味着该实例的内部被 -ed。AA(3)formyArrayAdelete []

所以我认为我的语法一定大错特错？我想有一些修复程序似乎有点矫枉过正，我希望避免：

为创建复制构造函数。A
使用，所以我不必担心这一切。vector<int>vector<A>
与其让它成为对象数组，不如让它成为指针数组。arrayOfAsAA*

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

（另外，风格批评也很欣赏，因为我已经有一段时间没有做C++了。

为未来的观众更新：下面的所有答案都非常有帮助。Martin's 之所以被接受，是因为示例代码和有用的“4 法则”，但我真的建议将它们全部阅读。有些是好的，简洁地陈述了什么是错的，有些则正确地指出了如何以及为什么是一条好路。vector

C++ 内存管理指针析构函数复制构造函数

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 []。因此，另一个对象（在数组中）现在包含一个指向已返回到系统的内存的指针。

编译器生成的复制构造函数;使用该 Members Copy 构造函数复制每个成员变量。对于指针，这仅意味着指针值从源对象复制到目标对象（因此是浅拷贝）。

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

因此，对于包含指针的类，最小值：

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

动态分配对象数组

Dynamically allocating an array of objects

评论

评论

评论

评论