Для создания контейнеров Вы, очевидно, хотите использовать один из стандартных контейнеров (таких как станд.:: вектор). Но это - идеальный пример вещей, которые необходимо рассмотреть, когда объект содержит НЕОБРАБОТАННЫЕ указатели.

, Если Ваш объект имеет НЕОБРАБОТАННЫЙ указатель тогда, необходимо помнить правило 3 (теперь правило 5 в C++ 11).

• Конструктор
• Деструктор
• Конструктор Копии
• Оператор присваивания
• Конструктор Перемещения (C++ 11)
• Присвоение Перемещения (C++ 11)

Это вызвано тем, что, если не определенный компилятор генерирует свою собственную версию этих методов (см. ниже). Сгенерированные версии компилятора не всегда полезны при контакте с НЕОБРАБОТАННЫМИ указателями.

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

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

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

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

сгенерированный оператор присваивания компилятора хорошо почти для всех ситуаций, но когда НЕОБРАБОТАННЫЕ указатели находятся в игре, необходимо обратить внимание. В Вашем случае это вызывает проблему из-за мелкая копия проблема. Вы закончили с двумя объектами, которые содержат указатели на ту же часть памяти. Когда (3) выходит из объема в конце цикла, это звонит, удаляют [] на его указателе. Таким образом другой объект (в массиве) теперь содержит указатель на память, которая была возвращена к системе.

компилятор генерировал конструктора копии ; копии каждая членская переменная при помощи того участники копируют конструктора. Для указателей это просто означает, что значение указателя копируется от исходного объекта до целевого объекта (следовательно мелкая копия).

компилятор генерировал оператор присваивания ; копии каждая членская переменная при помощи того членского оператора присваивания. Для указателей это просто означает, что значение указателя копируется от исходного объекта до целевого объекта (следовательно мелкая копия).

Так минимум для класса, который содержит указатель:

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