• После инициализации ссылку невозможно установить на другой объект.
• Присвоение ссылок основано на глубоком копировании (новое значение присваивается объекту, на который указывает ссылка); присвоение указателей не использует глубокое копирование (новое значение присваивается указателю, а не объекту).
• Нулевые указатели представляют опасность.
Рассмотрим пример.
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
в этом случае следует генерировать исключение.
