могут возникнуть трудноуловимые и опасные ошибки. Если вы используете оператор reinterpret_cast, то не следует ожидать, что ваша программа будет без проблем работать на другом компьютере.
17.9. Указатели и ссылки
Ссылку (reference) можно интерпретировать как автоматически разыменовываемый постоянный указатель или альтернативное имя объекта. Указатели и ссылки отличаются следующими особенностями.
• Присвоение чего-либо указателю изменяет значение указателя, а не объекта, на который он установлен.
• Для того чтобы получить указатель, как правило, необходимо использовать оператор new или &.
• Для доступа к объекту, на который установлен указатель, используются операторы * и [].
• Присвоение ссылке нового значения изменяет значение объекта, на который она ссылается, а не саму ссылку.
• После инициализации ссылку невозможно установить на другой объект.
• Присвоение ссылок основано на глубоком копировании (новое значение присваивается объекту, на который указывает ссылка); присвоение указателей не использует глубокое копирование (новое значение присваивается указателю, а не объекту).
• Нулевые указатели представляют опасность.
Рассмотрим пример.
int x = 10;
int* p = &x; // для получения указателя нужен оператор &
*p = 7; // для присвоения значения переменной x
// через указатель p используется *
int x2 = *p; // считываем переменную x с помощью указателя p
int* p2 = &x2; // получаем указатель на другую переменную
// типа int
p2 = p; // указатели p2 и p ссылаются на переменную x
p = &x2; // указатель p ссылается на другой объект
Соответствующий пример, касающийся ссылок, приведен ниже.
int y = 10;
int& r = y; // символ & означает тип, а не инициализатор
r = 7; // присвоение значения переменной y
// с помощью ссылки r (оператор * не нужен)
int y2 = r; // считываем переменную y с помощью ссылки r
// (оператор * не нужен)
int& r2 = y2; // ссылка на другую переменную типа int
r2 = r; // значение переменной y присваивается
// переменной y2
r = &y2; // ошибка: нельзя изменить значение ссылки
// (нельзя присвоить переменную int* ссылке int&)
Обратите внимание на последний пример; это значит не только то, что эта конструкция неработоспособна, — после инициализации невозможно связать ссылку с другим объектом. Если вам нужно указать на другой объект, используйте указатель. Использование указателей описано в разделе 17.9.3.
Как ссылка, так и указатель основаны на адресации памяти, но предоставляют программисту разные возможности.
17.9.1. Указатели и ссылки как параметры функций
Если хотите изменить значение переменной на значение, вычисленное функцией, у вас есть три варианта. Рассмотрим пример.
int incr_v(int x) { return x+1; } // вычисляет и возвращает новое
// значение
void incr_p(int* p) { ++*p; } // передает указатель
// (разыменовывает его
// и увеличивает значение
// на единицу)
void incr_r(int& r) { ++r; } // передает ссылку
Какой выбор вы сделаете? Скорее всего, выберете возвращение значения (которое наиболее уязвимо к ошибкам).
int x = 2;
x = incr_v(x); // копируем x в incr_v(); затем копируем результат
// и присваиваем его вновь
Этот стиль предпочтительнее для небольших объектов, таких как переменные типа int. Однако передача значений туда и обратно не всегда реальна. Например, можно написать функцию, модифицирующую огромную структуру данных, такую как вектор, содержащий 10 тыс. переменных типа int; мы не можем копировать эти 40 тыс. байтов (как минимум, вдвое) с достаточной эффективностью.
Как сделать выбор между передачей аргумента по ссылке и с помощью указателя? К сожалению, каждый из этих вариантов имеет свои преимущества и недостатки, поэтому ответ на это вопрос не ясен. Каждый программист должен принимать решение в зависимости от ситуации.
Использование передачи аргумента с помощью ссылок предостерегает программиста о том, что значение может измениться. Рассмотрим пример.
int x = 7;
incr_p(&x); // здесь необходим оператор &
incr_r(x);
Необходимость использования оператора & в вызове функции incr_p(&x) обусловлена тем, что пользователь должен знать о том, что переменная x может измениться. В противоположность этому вызов функции incr_r(x) “выглядит невинно”. Это свидетельствует о небольшом преимуществе передачи указателя.
С другой стороны, если в качестве аргумента функции вы используете указатель, то следует опасаться, что функции будет передан нулевой указатель, т.е. указатель с нулевым значением. Рассмотрим пример.
incr_p(0); // крах: функция incr_p() пытается разыменовать нуль
int* p = 0;
incr_p(p); // крах: функция incr_p() пытается разыменовать нуль
Совершенно очевидно, что это ужасно. Человек, написавший функцию, incr_p(), может предусмотреть защиту.
void incr_p(int* p)
{
if (p==0) error("Функции incr_p() передан нулевой указатель");
++*p; // разыменовываем указатель и увеличиваем на единицу
// объект, на который он установлен
}
Теперь функция incr_p() выглядит проще и приятнее, чем раньше. В главе 5 было показано, как устранить проблему, связанную с некорректными аргументами. В противоположность этому пользователи, применяющие ссылки (например, в функции incr_r()), должны предполагать, что ссылка связана с объектом. Если “передача пустоты” (когда объект на самом деле не передается) с точки зрения семантики функции вполне допустима, аргумент следует передавать с помощью указателя. Примечание: это не относится к операции инкрементации — поскольку при условии p==0 в этом случае следует генерировать исключение.
Итак, правильный ответ формулируется так: выбор зависит от природы функции.
• Для маленьких объектов предпочтительнее передача по значению.
• Для функций, допускающих в качестве своего аргумента “нулевой объект” (представленный значением 0), следует использовать передачу указателя (и не забывать проверку нуля).
• В противном случае в качестве параметра следует использовать ссылку.
См. также раздел 8.5.6.
17.9.2. Указатели, ссылки и наследование
В разделе 14.3 мы видели, как можно использовать производный класс, такой как Circle, вместо объекта его открытого базового класса Shape. Эту идею можно выразить в терминах указателей или ссылок: указатель Circle* можно неявно преобразовать в указатель
