Динамическое выделение массива объектов

для построения контейнеров вы, очевидно, хотите использовать один из стандартных контейнеров (например, std::vector). Но это прекрасный пример того, что вам нужно учитывать, когда ваш объект содержит необработанные указатели.

Если ваш объект имеет необработанный указатель, то вам нужно запомнить правило 3 (Теперь правило 5 В C++11).

• конструктор
• деструктор
• Конструктор Копирования
• Оператор Присваивания
• переместить Конструктор (C++11)
• Переместить Назначение (C++11)

Это потому, что если он не определен, то компилятор будет генерировать свою собственную версию этих методов (см. ниже). Созданные компилятором версии не всегда полезны при работе с необработанными указателями.

конструктор копирования трудно получить правильно (это нетривиально, если вы хотите предоставить гарантию сильного исключения). Оператор присваивания может быть определен в терминах конструктора копирования как вы может использовать идиому копирования и замены внутри.

см. ниже полную информацию об абсолютном минимуме для класса, содержащего указатель на массив целых чисел.

зная, что это нетривиально, чтобы получить его правильно, вы должны рассмотреть возможность использования std::vector, а не указатель на массив целых чисел. Вектор прост в использовании (и расширении) и охватывает все проблемы, связанные с исключениями. Сравните следующий класс с определением под.

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

оператор присваивания, сгенерированный компилятором, подходит почти для всех ситуаций, но когда необработанные указатели находятся в игре, вам нужно обратить внимание. В вашем случае это вызывает проблему из-за мелкая копия проблема. Вы получили два объекта, которые содержат указатели на один и тот же фрагмент памяти. Когда 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;
         }   
 }