Программирование. Принципы и практика использования C++ Исправленное издание - Бьёрн Страуструп

могут возникнуть трудноуловимые и опасные ошибки. Если вы используете оператор 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* можно неявно преобразовать в указатель