Освой самостоятельно С++ за 21 день.
Шрифт:
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: }
Результат: