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

• После инициализации ссылку невозможно установить на другой объект.

• Присвоение ссылок основано на глубоком копировании (новое значение присваивается объекту, на который указывает ссылка); присвоение указателей не использует глубокое копирование (новое значение присваивается указателю, а не объекту).

• Нулевые указатели представляют опасность.

Рассмотрим пример.

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)
“выглядит невинно”. Это свидетельствует о небольшом преимуществе передачи указателя.

 

Программирование. Принципы и практика использования C++ Исправленное издание - _003.png
 С другой стороны, если в качестве аргумента функции вы используете указатель, то следует опасаться, что функции будет передан нулевой указатель, т.е. указатель с нулевым значением. Рассмотрим пример.

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
в этом случае следует генерировать исключение.