class="code">delete (подробнее об этом — в разделе 17.4.6). Однако такая проверка часто оказывается лучшим, что можно сделать. Мы не обязаны явно указывать нуль, поскольку инструкция if по умолчанию проверяет, является ли условие ненулевым.
if (p0) // проверка корректности указателя p0; эквивалентно p0!=0
Мы предпочитаем более короткую форму проверки, полагая, что она точнее отражает смысл выражения “p0 корректен”, но это дело вкуса.
Нулевой указатель следует использовать тогда, когда некий указатель то ссылается на какой-нибудь объект, то нет. Эта ситуация встречается реже, чем можно себе представить; подумайте: если у вас нет объекта, на который можно установить указатель, то зачем вам определять сам указатель? Почему бы не подождать, пока не будет создан объект?
17.4.6. Освобождение свободной памяти
Оператор new выделяет участок свободной памяти. Поскольку память компьютера ограничена, неплохо было бы возвращать память обратно, когда она станет больше ненужной. В этом случае освобожденную память можно было бы использовать для хранения других объектов. Для больших и долго работающих программ такое освобождение памяти играет важную роль. Рассмотрим пример.
double* calc(int res_size, int max) // утечка памяти
{
double* p = new double[max];
double* res = new double[res_size];
// используем указатель p для вычисления результатов
// и записи их в массив res
return res;
}
double* r = calc(100,1000);
В соответствии с этой программой каждый вызов функции calc() будет забирать из свободной памяти участок, размер которого равен размеру типа double, и присваивать его адрес указателю p. Например, вызов calc(100,1000) сделает недоступным для остальной части программы участок памяти, на котором могут разместиться тысяча переменных типа double.
Оператор, возвращающий освобождающую память, называется delete. Для того чтобы освободить память для дальнейшего использования, оператор delete следует применить к указателю, который был возвращен оператором new. Рассмотрим пример.
double* calc(int res_size, int max)
// за использование памяти, выделенной для массива res,
// несет ответственность вызывающий модуль
{
double* p = new double[max];
double* res = new double[res_size];
// используем указатель p для вычисления результатов и их
// записи в res
delete[ ] p; // эта память больше не нужна: освобождаем ее
return res;
}
double* r = calc(100,1000);
// используем указатель r
delete[ ] r; // эта память больше не нужна: освобождаем ее
Между прочим, этот пример демонстрирует одну из основных причин использования свободной памяти: мы можем создавать объекты в функции и передавать их обратно в вызывающий модуль.
Оператор delete имеет две формы:
• delete p освобождает память, выделенную с помощью оператора new для отдельного объекта;
• delete[] p освобождает память, выделенную с помощью оператора new для массива объектов.
Выбор правильного варианта должен сделать программист.
Двойное удаление объекта — очень грубая ошибка. Рассмотрим пример.
int* p = new int(5);
delete p; // отлично: p ссылается на объект, созданный оператором new
// ...указатель здесь больше не используется...
delete p; // ошибка: p ссылается на память, принадлежащую диспетчеру
// свободной памяти
Вторая инструкция delete p порождает две проблемы.
• Вы больше не ссылаетесь на объект, поэтому диспетчер свободной памяти может изменить внутреннюю структуру данных так, чтобы выполнить инструкцию delete p правильно во второй раз было невозможно.
• Диспетчер свободной памяти может повторно использовать память, на которую ссылался указатель p, так что теперь указатель p ссылается на другой объект; удаление этого объекта (принадлежащего другой части программы) может вызвать ошибку.
Обе проблемы встречаются в реальных программах; так что это не просто теоретические возможности.
Удаление нулевого указателя не приводит ни к каким последствиям (так как нулевой указатель не ссылается ни на один объект), поэтому эта операция безвредна. Рассмотрим пример.
int* p = 0;
delete p; // отлично: никаких действий не нужно
delete p; // тоже хорошо (по-прежнему ничего делать не нужно)
Зачем возиться с освобождением памяти? Разве компилятор сам не может понять, когда память нам больше не нужна, и освободить ее без вмешательства человека? Может. Такой механизм называется автоматической сборкой мусора (automatic garbage collection) или просто сборкой мусора (garbage collection). К сожалению, автоматическая сборка мусора недешевое удовольствие и не идеально подходит ко всем приложениям. Если вам действительно нужна автоматическая сборка мусора, можете встроить этот механизм в свою программу. Хорошие сборщики мусора доступны по адресу www.research.att.com/~bs/C++.html. Однако в этой книге мы предполагаем, что читатели сами разберутся со своим “мусором”, а мы покажем, как это сделать удобно и эффективно.
Почему следует избегать утечки памяти? Программа, которая должна работать бесконечно, не должна допускать никаких утечек памяти. Примером таких программ является операционная система, а также большинство встроенных систем (о них речь пойдет в главе 25). Библиотеки также не должны допускать утечек памяти, поскольку кто-нибудь может использовать эти библиотеки как часть системы, работающей бесконечно. В общем, утечек памяти следует избегать, и все тут. Многие программисты рассматривают утечки памяти как проявление неряшливости. Однако эта точка зрения кажется нам слишком категоричной. Если программа выполняется под управлением операционной системы (Unix, Windows или какой-нибудь еще), то после завершения работы программы вся память будет автоматически возвращена системе. Отсюда следует, что если вам известно, что ваша программа не будет использовать больше памяти, чем ей доступно, то вполне можно допустить утечку, пока операционная система сама не восстановит порядок. Тем не менее, если вы решитесь на это, то надо быть уверенным в том, что ваша оценка объема используемой памяти является правильной, иначе вас сочтут неряхой.
17.5. Деструкторы
Теперь мы знаем, как хранить элементы в векторе. Мы просто выделим достаточное количество свободной памяти и будем обращаться к ней с помощью указателя.
// очень упрощенный вектор, содержащий числа типа double
class vector {
int sz; // размер
double* elem; // указатель на элементы
public:
vector(int s) // конструктор
:sz(s), // инициализация члена sz
elem(new double[s]) // инициализация члена elem
