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

  alloc.deallocate(elem,space); // освобождаем старую память
  elem = p;
  space = newalloc;
 }

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

Имея функции reserve, vector<T,A>::push_back, можно без труда написать следующий код.

 template<class T, class A>
 void vector<T,A>::push_back(const T& val)
 {
  if (space==0) reserve(8); // начинаем с памяти для 8 элементов
  else if (sz==space) reserve(2*space); // выделяем больше памяти
  alloc.construct(&elem[sz],val); // добавляем в конец
  // значение val
  ++sz; // увеличиваем размер
 }

Аналогично можно написать функцию vector<T,A>::resize.

 template<class T, class A>
 void vector<T,A>::resize(int newsize, T val = T)
 {
  reserve(newsize);
  for (int i=sz; i<newsize; ++i) alloc.construct(&elem[i],val);
  // создаем
  for (int i = newsize; i<sz; ++i) alloc.destroy(&elem[i]);
  // уничтожаем
  sz = newsize;
 }

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

Другое новшество — деструктор избыточных элементов при уменьшении вектора. Представьте себе деструктор, превращающий объект определенного типа в простой набор ячеек памяти.

“Непринужденное обращение с распределителями памяти” — это довольно сложное и хитроумное искусство. Не старайтесь злоупотреблять им, пока не почувствуете, что стали экспертом.

19.4. Проверка диапазона и исключения

Мы проанализировали текущее состояние нашего класса vector и обнаружили (с ужасом?), что в нем не предусмотрена проверка выхода за пределы допустимого диапазона. Реализация оператора operator[] не вызывает затруднений.

 template<class T, class A> T& vector<T,A>::operator[](int n)
 {
  return elem[n];
 }

Рассмотрим следующий пример:

 vector<int> v(100);
 v[–200] = v[200]; // Ой!
 int i;
 cin>>i;
 v[i] = 999; // повреждение произвольной ячейки памяти

Этот код компилируется и выполняется, обращаясь к памяти, не принадлежащей нашему объекту класса vector. Это может создать большие неприятности! В реальной программе такой код неприемлем. Попробуем улучшить наш класс vector, чтобы решить эту проблему. Простейший способ — добавить в класс операцию проверки доступа с именем at.

 struct out_of_range { /* ... */ }; // класс, сообщающий об ошибках,
 // связанных с выходом за пределы допустимого диапазона
 template<class T, class A = allocator<T> > class vector {
  // ...
  T& at(int n); // доступ с проверкой
  const T& at(int n) const; // доступ с проверкой
  T& operator[](int n); // доступ без проверки
  const T& operator[](int n) const; // доступ без проверки
  // ...
 };

 template<class T, class A > T& vector<T,A>::at(int n)
 {
  if (n<0 || sz<=n) throw out_of_range;
  return elem[n];
 }

 template<class T, class A > T& vector<T,A>::operator[](int n)
 // как прежде
 {
  return elem[n];
 }

Итак, мы можем написать следующую функцию:

 void print_some(vector<int>& v)
 {
  int i = –1;
  cin >> i;
  while(i!= –1) try {
  cout << "v[" << i << "]==" << v.at(i) << "\n";
  }
  catch(out_of_range) {
  cout << "Неправильный индекс: " << i << "\n";
  }
 }

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

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

19.4.1. Примечание: вопросы проектирования

Итак, все хорошо, но почему бы нам не включить проверку выхода за пределы допустимого диапазона в функцию operator[]? Тем не менее, как показано выше, стандартный класс vector содержит отдельную функцию at с проверкой доступа и функцию operator[] без проверки. Попробуем обосновать это решение. Оно основывается на четырех аргументах.