double* elem; // указатель на элементы
public:
vector(int s) // конструктор
:sz(s), elem(new double[s]) { /* */ } // выделяет
// память
~vector() // деструктор
{ delete[ ] elem; } // освобождает
// память
// ...
};
Попробуем скопировать один из таких векторов.
void f(int n)
{
vector v(3); // определяем вектор из трех элементов
v.set(2,2.2); // устанавливаем v[2] равным 2.2
vector v2 = v; // что здесь происходит?
// ...
}
Теоретически объект
v2
должен стать копией объекта
v
(т.е. оператор = создает копии); иначе говоря, для всех
i
в диапазоне
[0:v.size()]
должны выполняться условия
v2.size()==v.size()
и
v2[i]==v[i]
. Более того, при выходе из функции
f()
вся память возвращается в свободный пул. Именно это (разумеется) делает класс
vector
из стандартной библиотеки, но не наш слишком простой класс
vector
. Наша цель — улучшить наш класс
vector
, чтобы правильно решать такие задачи, но сначала попытаемся понять, как на самом деле работает наша текущая версия. Что именно она делает неправильно, как и почему? Поняв это, мы сможем устранить проблему. Еще более важно то, что мы можем распознать аналогичные проблемы, которые могут возникнуть в других ситуациях.
По умолчанию копирование относительно класса означает “скопировать все данные-члены”. Это часто имеет смысл. Например, мы копируем объект класса
Point
, копируя его координаты. Однако при копировании членов класса, являющихся указателями, возникают проблемы. В частности, для векторов в нашем примере выполняются условия
v.sz==v2.sz
и
v.elem==v2.elem
, так что наши векторы выглядят следующим образом:
Иначе говоря, объект
v2
не содержит копии элементов объекта
v
; он ими владеет совместно с объектом
v
. Мы могли бы написать следующий код:
v.set(1,99); // устанавливаем v[1] равным 99
v2.set(0,88); // устанавливаем v2[0] равным 88
cout << v.get(0) << ' ' << v2.get(1);
В результате мы получили бы вектор
88
99
. Это не то, к чему мы стремились. Если бы не существовало скрытой связи между объектами
v
и
v2
, то результат был бы равен
0
0
, поскольку мы не записывали никаких значений в ячейку
v[0]
или
v2[1]
. Вы могли бы возразить, что такое поведение является интересным, аккуратным или иногда полезным, но мы не этого ждали, и это не то, что реализовано в стандартном классе
vector
. Кроме того, когда мы вернем результат из функции
f()
, произойдет явная катастрофа. При этом неявно будут вызваны деструкторы объектов
v
и
v2
; деструктор объекта
v
освободит использованную память с помощью инструкции
delete[] elem;
И то же самое сделает деструктор объекта
v2
. Поскольку в обоих объектах,
v
и
v2
, указатель
elem
ссылается на одну ту же ячейку памяти, эта память будет освобождена дважды, что может привести к катастрофическим результатам (см. раздел 17.4.6).
18.2.1. Конструкторы копирования
Итак, что делать? Это очевидно: необходимо предусмотреть операцию копирования, которая копировала бы элементы и вызывалась при инициализации одного вектора другим. Следовательно, нам нужен конструктор, создающий копии. Такой конструктор, очевидно, называется копирующим (copy constructor). В качестве аргумента он принимает ссылку на объект, который подлежит копированию. Значит, класс
vector
должен выглядеть следующим образом:
vector(const vector&);
Этот конструктор будет вызываться, когда мы попытаемся инициализировать один объект класса
vector
другим. Мы передаем объект по ссылке, поскольку не хотим (очевидно) копировать аргумент конструктора, который определяет суть копирования. Мы передаем эту ссылку со спецификатором
const
, потому что не хотим модифицировать аргумент (см. раздел 8.5.6). Уточним определение класса
vector
.
class vector {
int sz;
double* elem;
void copy(const vector& arg); // копирует элементы copy
// из arg в *elem
public:
vector(const vector&); // конструктор копирования
// ...
};
Функция-член
copy()
просто копирует элементы из вектора, являющегося аргументом.
void vector::copy(const vector& arg)
// копирует элементы [0:arg.sz–1]
{
for (int i = 0; i<arg.sz; ++i) elem[i] = arg.elem[i];
