Когда указатели не инициализированы или когда они освобождены, им следует присваивать нулевое значение (0). Это не касается ссылок. На самом деле ссылка не может быть нулевой, и программа, содержащая ссылку на нулевой объект, считается некорректной. Во время работы некорректной программы может случиться все что угодно. Она может внешне вести себя вполне пристойно, но при этом удалит все файлы на вашем диске или выкинет еще какой-нибудь фокус.
Большинство компиляторов могут поддерживать нулевой объект, ничего не сообщая по этому поводу до тех пор, пока вы не попытаетесь каким-то образом использовать этот объект. Однако не советую пользоваться поблажками компилятора, поскольку они могут дорого вам обойтись во время выполнения программы.
Передача аргументов функций как ссылок
На занятии 5 вы узнали о том, что функции имеют два ограничения: аргументы передаются как значения и теряют связь с исходными данными, а возвращать функция может только одно значение.
Преодолеть эти два ограничения можно путем передачи функции аргументов как ссылок. В языке C++ передача данных как ссылок осуществляется двумя способами: с помощью указателей и с помощью ссылок. Не запутайтесь в терминах: вы можете передать аргумент как ссылку, используя либо указатель, либо ссылку.
Несмотря на то что синтаксис использования указателя отличается от синтаксиса использования ссылки, конечный эффект одинаков. Вместо копии, создаваемой в пределах области видимости функции, в функцию передается реальный исходный объект.
На занятии 5 вы узнали, что параметры, передаваемые функции, помешаются в стек. Если функции передается значение как ссылка (с помощью либо указателей, либо ссылок), то в стек помещается не сам объект, а его адрес.
В действительности в некоторых компьютерах адрес хранится в специальном регистре, а в стек ничего не помещается. В любом случае компилятору известно, как добраться до исходного объекта, и при необходимости все изменения производятся прямо над объектом, а не над его временной копией.
При передаче объекта как ссылки функция может изменять объект, просто ссылаясь на него.
Вспомните, что в листинге 5.5 (см. Занятие 5) демонстрировалось, что после обращения к функции swap() значения в вызывающей функции не изменялись. Исключительно ради вашего удобства этот листинг воспроизведен здесь еще раз (листинг 9.5).
Листинг 9.5. Демонстрация передачи по значению
1: // Листинг 9.5. Передача параметров как значений
2:
3: #include <iostrearn.h>
4:
5: void swap(int x, int у);
6:
7: int main()
8: {
9: int x = 5, у = 10;
10:
11: cout << "Main. Before swap, x: " << x << " у: " << у << "\n";
12: swap(x,у);
13: cout << "Main. After swap, x: " << x << " у: " << у << "\n";
14: return 0;
15: }
16:
17: void swap(int x, int у);
18: {
19: int temp;
20:
21: cout << "Swap. After swap, x; " << x << " у: " << у << "\n";
22:
23: temp = x;
24: x = у;
25: у = temp;
26:
27: cout << "Swap. Before swap, x: " << x << " у: " << у << "\n";
28:
29: }
Результат:
Main. Before swap, x: 5 у: 10
Swap. Before swap, x: 5 у: 10
Swap. After swap, x: 10 у: 5
Main. After swap, x: 5 у: 10
Эта программа инициализирует две переменные в функции main(), а затем передает их функции swap(), которая, казалось бы, должна поменять их значения. Однако после повторной проверки этих переменных в функции main() оказывается, что они не изменились.
Проблема здесь в том, что переменные x и у передаются функции swap() по значению, т.е. в данном случае локальные копии этих переменных создаются прямо в функции. Чтобы решить проблему, нужно передать значения переменных x и у как ссылки,
В языке C++ существует два способа решения этой проблемы: можно сделать параметры функции swap() указателями на исходные значения или передать ссылки на исходные значения.
Передача указателей в функцию swap()
Передавая указатель, мы передаем адрес объекта, а следовательно, функция может манипулировать значением, находящимся по этому переданному адресу. Чтобы заставить функцию swap() изменить реальные значения с помощью указателей, ее нужно объявить так, чтобы она принимала два указателя на целые значения. Затем путем разыменования указателей значения переменных x и у будут на самом деле меняться местами. Эта идея демонстрируется в листинге 9.6.
Листинг 9.6. Передача аргументов как ссылок с помощью указателей
1: // Листинг 9.6. Пример передечи аргументов как ссылок
2:
3: #include <iostream.h>
4:
5: void swap (int *x, int *y)
6:
7: int main()
8: {
9: int x = 5, у = 10;
10:
11: cout << "Main. Before swap, x: " << x << " у: " << у << "\n";
12: swap(&x,&y);
13: cout << "Main. After swap, x: " << x << " у: " << у << "\n";
14: return 0;
15: }
16:
17: void swap (int *px, int *py)
18: {
19: int temp;
20:
21: cout << "Swap. Before swap, *рх: " << *px << " *py: " << *py << "\n";
22:
23: temp = *px;
24: *px = *py;
25: *py = temp;
26:
27: cout << "Swap. After swap, *px: " << *px << " *py: " << *py << "\n";
28:
29: }
Результат:
Main. Before swap, x: 5 y: 10
Swap. Before swap, *px: 5 *py: 10
Swap. After swap, *px: 10 *py: 5
Main. After swap, x: 10 y: 5
Анализ: Получилось! В строке 5 изменен прототип функции swap() где в качестве параметров объявляются указатели на значения типа int, а не сами переменные типа int. При вызове в строке 12 функции swap() в качестве параметров передаются адреса переменных x и у.
В строке 19 объявляется локальная для функции swap() переменная temp, которой вовсе не обязательно быть указателем: она будет просто хранить значение *px (т.е. значение переменной x в вызывающей функции) в течение жизни функции. После окончания работы функции переменная temp больше не нужна.
В строке 23 переменной temp присваивается значение, хранящееся по адресу px. В строке 24 значение, хранящееся по адресу px, записывается в ячейку с адресом py. В строке 25 значение, оставленное на время в переменной temp (т.е. исходное значение, хранящееся по адресу px), помещается в ячейку с адресом py.
В результате значения переменных вызывающей функции, адреса которых были переданы функции swap(), успешно поменялись местами.
Передача ссылок в функцию swap()
Приведенная выше программа, конечно же, работает, но синтаксис функции swap() несколько громоздок. Во-первых, необходимость неоднократно разыменовывать указатели внутри функции swap() создает благоприятную почву для возникновения ошибок, кроме того, операции разыменовывания трудно читаются. Во-вторых, необходимость передавать адреса переменных из вызывающей функции нарушает принцип инкапсуляции выполнения функции swap().
Суть программирования на языке C++ состоит в сокрытии от пользователей функции деталей ее выполнения. Передача параметров с помощью указателей перекладывает ответственность за получение адресов переменных на вызывающую функцию, вместо того чтобы сделать это в теле вызываемой функции. Другое решение той же задачи предлагается в листинге 9.7, в котором показана работа функции swap() с использованием ссылок.
Листинг 9.7. Та же фцнкция swap(), но с использованием ссылок
1: // Листинг 9.7. Пример передачи аргументов как
2: // ссылок с помощью ссылок!
3:
4: #include <iostream.h>
5:
6: void swap(int &x, int &y);
7:
8: int main()
9: {
10: int x = 5, у = 10;
11:
12: cout << "Main. Before swap, x: " << x << " у: " << у << "\n";
13: swap(x,у);
14: cout << "Main. After swap, x: " << x << " у: " << у << "\n";
15: return 0;
16: }
17:
18: void swap(int &rx, int &ry)
19: {
20: int temp;
21:
22: cout << "Swap. Before swap, rx: " << rx << " ry: " << ry << "\n";
23:
24: temp = rx;
25: rx = ry;
26: ry = temp;
27:
28: cout << "Swap. After swap, rx: " << rx << " ry: " << ry << "\n";
29:
30: }
Результат:
Main. Before swap, x:5 y: 10
Swap. Before swap, rx:5 ry:10
Swap. After swap, rx:10 ry:5
Main. After swap, x:10, y:5
Анализ: Точно так же, как и в примере с указателями, в строке 10 объявляются две переменные, а их значения выводятся на экран в строке 12. В строке 13 вызывается функция swap(), но обратите внимание на то, что ей передаются именно значения x и у, а не их адреса. Вызывающая функция просто передает свои переменные.
После вызова функции swap() выполнение программы переходит к строке 18, в которой эти переменные идентифицируются как ссылки. Их значения выводятся на экран в строке 22, но заметьте, что для этого не требуется никаких специальных операторов, поскольку мы имеем дело с псевдонимами для исходных значений и используем их в этом качестве.
В строках 24—26 выполняется обмен значений, после чего они выводятся на экран в строке 28. Управление программой вновь возвращается в вызывающую функцию, и в строке 14 эти значения опять выводятся на экран, но уже в функции main(). Поскольку параметры для функции swap() объявлены как ссылки, то и переменные из функции main() передаются как ссылки, следовательно, они также изменяются и в функции main().
Таким образом, благодаря использованию ссылок функция приобретает новую возможность изменять исходные данные в вызывающей функции, хотя при этом сам вызов функции ничем не отличается от обычного!