Программирование. Принципы и практика использования C++ Исправленное издание, стр. 255

                                              // новые элементы

  sz = newsize;

}

Основная работа с памятью поручена функции

reserve()
. Цикл инициализирует новые элементы (если они есть).

Мы не выделяли каждый из этих вариантов явно, но, как легко проверить, все они, тем не менее, обработаны правильно.

ПОПРОБУЙТЕ

Какие варианты следует предусмотреть (и протестировать), если мы хотим убедиться, что данная функция

resize()
работает правильно? Что скажете об условиях
newsize==0
и
newsize==–77
?

19.2.4. Функция push_back

При первом рассмотрении функция

push_back()
может показаться сложной для реализации, но функция
reserve()
все упрощает.

void vector::push_back(double d)

 // увеличивает размер вектора на единицу;

 // инициализирует новый элемент числом d

{

  if (space==0) reserve(8); // выделяет память для 8

                            // элементов

  else if (sz==space) reserve(2*space); // выделяет дополнительную

                                        // память

  elem[sz] = d;  // добавляет d в конец вектора

  ++sz;          // увеличивает размер (sz — количество элементов)

}

Другими словами, если у нас нет свободной памяти, то удваиваем размер выделенной памяти. На практике эта стратегия оказывается очень удачной, поэтому она используется в стандартном библиотечном классе

vector
.

19.2.5. Присваивание

Присваивание векторов можно определить несколькими способами. Например, мы могли бы допускать присваивание, только если векторы имеют одинаковое количество элементов. Однако в разделе 18.2.2 мы решили, что присваивание векторов должно иметь более общий характер и более очевидный смысл: после присваивания

v1=v2
вектор
v1
является копией вектора
v2
. Рассмотрим следующий рисунок.

Программирование. Принципы и практика использования C++ Исправленное издание - _212.png

Очевидно, что мы должны скопировать элементы, но есть ли у нас свободная память? Можем ли мы скопировать вектор в свободную память, расположенную за его последним элементом? Нет! Новый объект класса

vector
будет хранить копии элементов, но поскольку мы еще не знаем, как он будет использоваться, то не выделили свободной памяти в конце вектора.

Простейшая реализация описана ниже.

• Выделяем память для копии.

• Копируем элементы.

Программирование. Принципы и практика использования C++ Исправленное издание - _213.png

• Освобождаем старую память.

• Присваиваем членам

sz
,
elem
и
space
новые значения.

Код будет выглядеть примерно так:

vector& vector::operator=(const vector& a)

 // похож на конструктор копирования,

 // но мы должны работать со старыми элементами

{

  double* p = new double[a.sz];     // выделяем новую память

  for (int i = 0; i<a.sz; ++i) p[i] = a.elem[i]; // копируем

                                                 // элементы

  delete[] elem;     // освобождаем старую память

  space = sz = a.sz; // устанавливаем новый размер

  elem = p;          // устанавливаем новые элементы

  return *this;      // возвращаем ссылку на себя

}

Согласно общепринятому соглашению оператор присваивания возвращает ссылку на целевой объект. Смысл выражения

*this
объяснялся в разделе 17.10. Его реализация является корректной, но, немного поразмыслив, легко увидеть, что мы выполняем избыточные операции выделения и освобождения памяти. Что делать, если целевой вектор содержит больше элементов, чем присваиваемый вектор? Что делать, если целевой вектор содержит столько же элементов, сколько и присваиваемый вектор? Во многих приложениях последняя ситуация встречается чаще всего. В любом случае мы можем просто скопировать элементы в память, уже выделенную ранее целевому вектору.

vector& vector::operator=(const vector& a)

{

  if (this==&a) return *this;  // самоприсваивание, ничего делать

                               // не надо

  if (a.sz<=space) {           // памяти достаточно, новая память

                               // не нужна

  for (int i = 0; i<a.sz; ++i) elem[i] = a.elem[i]; // копируем

  sz = a.sz;

  return *this;

}

  double* p = new double[a.sz]; // выделяем новую память

  for (int i = 0; i<a.sz; ++i) p[i] = a.elem[i]; // копируем

                                                 // элементы

  delete[] elem;      // освобождаем старую память

  space = sz = a.sz;  // устанавливаем новый размер

  elem = p;           // устанавливаем указатель на новые

                      // элементы

  return *this;       // возвращаем ссылку на целевой объект

}

В этом фрагменте кода мы сначала проверяем самоприсваивание (например,

v=v
); в этом случае ничего делать не надо. С логической точки зрения эта проверка лишняя, но иногда она позволяет значительно оптимизировать программу. Эта проверка демонстрирует использование указателя
this
, позволяющего проверить, является ли аргумент a тем же объектом, что и объект, из которого вызывается функция-член (т.е.
operator=()
). Убедитесь, что этот код действительно работает, если из него удалить инструкцию
this==&a
. Инструкция
a.sz<=space
также включена для оптимизации. Убедитесь, что этот код действительно работает после удаления из него инструкции
a.sz<=space
.