работает с неинициализированной памятью, и предоставить пользователям правильно сконструированные объекты. Единственный код, который следует изменить, — это функции-члены класса vector, непосредственно работающие с памятью, например функция vector<T>::reserve().
template<class T, class A>
void vector<T,A>::reserve(int newalloc)
{
if (newalloc<=space) return; // размер не уменьшается
T* p = alloc.allocate(newalloc); // выделяем новую память
for (int i=0; i<sz; ++i) alloc.construct(&p[i],elem[i]);
// копируем
for (int i=0; i<sz; ++i) alloc.destroy(&elem[i]); // уничтожаем
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[]() без проверки. Попробуем обосновать это решение. Оно основывается на четырех аргументах.
1. Совместимость. Люди использовали индексирование без проверки выхода за пределы допустимого диапазона задолго до того, как в языке C++ появились исключения.
2. Эффективность. Можно создать оператор с проверкой выхода за пределы допустимого диапазона на основе оптимально эффективного оператора индексирования без такой проверки, но невозможно создать оператор индексирования без проверки выхода за пределы допустимого диапазона, обладающий оптимальным быстродействием, на основе оператора доступа, выполняющего такую проверку.
3. Ограничения. В некоторых средах исключения не допускаются.
4. Необязательная проверка. На самом деле стандарт не утверждает, что вы не можете проверить диапазон в классе vector, поэтому, если хотите выполнить проверку, можете ее реализовать.
19.4.1.1. Совместимость
Люди очень не любят переделывать старый код. Например, если вы написали миллионы строк кода, то было бы очень дорого переделывать его полностью, чтобы корректно использовать исключения. Мы могли бы сказать, что после такой переделки код станет лучше, но не станем этого делать, поскольку не одобряем излишние затраты времени и денег. Более того, люди, занимающиеся сопровождением существующего кода, обычно утверждают, что в принципе код без проверки небезопасен, но их конкретная программа была протестирована и используется уже многие годы, так что в ней уже выявлены все ошибки. К этим аргументам можно относиться скептически, но в каждом конкретном случае следует принимать взвешенное решение. Естественно, нет никаких программ, которые использовали стандартный класс vector до того, как он появился в языке C++, но существуют миллионы строк кода, в которых используются очень похожие классы, но без исключений. Большинство
