Int main () {

IntArray a = fillArray ();

std::cout << a << '\n';

IntArray b (1);

a = a;

b = a;

std::cout << b << '\n';

return 0;

}

Выдавал следующий результат:

6 7 3 4 5 8

6 7 3 4 5 8

Ответ:

#include <iostream>

#include <cassert> // для assert

class IntArray

{

private:

int m_length = 0;

int* m_array = nullptr;

public:

IntArray(int length) :

m_length{ length }

{

assert(length > 0 && "IntArray length should be a positive integer");

m_array = new int[m_length] {};

}

// Конструктор копирования, использующий глубокое копирование

IntArray(const IntArray& array) :

m_length{ array.m_length }

{

// размещаем новый массив

m_array = new int[m_length];

// копируем элементы из исходного массива в новый

for (int count = 0; count < array.m_length; ++count)

m_array[count] = array.m_array[count];

}

~IntArray()

{

delete[] m_array;

}

// Если вы получаете здесь непонятные значения, вы, вероятно, забыли

// выполнить глубокое копирование в своем конструкторе копирования

friend std::ostream& operator<<(std::ostream& out, const IntArray& array)

{

for (int count = 0; count < array.m_length; ++count)

{

out << array.m_array[count] << ' ';

}

return out;

}

int& operator[] (const int index)

{

assert(index >= 0);

assert(index < m_length);

return m_array[index];

}

// Оператор присваивания, использующий глубокое копирование

IntArray& operator= (const IntArray& array)

{

// защита от самоприсваивания

if (this == &array)

return *this;

// если этот массив уже существует, удалить его,

// чтобы не было утечек памяти

delete[] m_array;

m_length = array.m_length;

// размещаем новый массив

m_array = new int[m_length];

// копируем элементы из исходного массива в новый

for (int count = 0; count < array.m_length; ++count)

m_array[count] = array.m_array[count];

return *this;

}

};

IntArray fillArray() {

IntArray a(6);

a[0] = 6;

a[1] = 7;

a[2] = 3;

a[3] = 4;

a[4] = 5;

a[5] = 8;

return a;

}

Int main()

{

IntArray a = fillArray();

std::cout << a << '\n';

IntArray b(1);

a = a;

b = a;

std::cout << b << '\n';

return 0;

}

/*Одно из решений этой проблемы – выполнить глубокое копирование любых копируемых ненулевых указателей. Глубокое копирование выделяет память для копии, а затем копирует фактическое значение, поэтому копия живет в отдельной памяти от источника. Таким образом, копия и источник различаются и никоим образом не влияют друг на друга. Выполнение глубокого копирования требует, чтобы мы написали наши собственные конструкторы копирования и перегруженные операторы присваивания.

Во-первых, мы даже должны проверить, есть ли в источнике строка. Если это так, то мы выделяем достаточно памяти для хранения копии этой строки. И в конце нам нужно вручную скопировать строку.

Обратите внимание, что наш оператор присваивания очень похож на наш конструктор копирования, но есть три основных отличия:

-мы добавили проверку на самоприсваивание;

-мы возвращаем *this, чтобы можно было добавить оператор присваивания в цепочку;

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