Листинг 9.3. Присвоение значения ссылке
1: // Листинг 9.3
2: // Присвоение значения ссылке
3:
4: #include <iostream.h>
5:
6: int main()
7: {
8: int intOne;
9: int &rSomeRef = intOne;
10:
11: intOne: 5
12: cout << "intOne:t" << intOne << endl;
13: cout << "rSomeRef:t" << rSomeRef << endl;
14: cout << "&intOne:t" << &intOne << endl;
15: cout << "&rSomeRef:t" << &rSomeRef << endl;
16:
17: int intTwo = 8;
18: rSomeRef = intTwo; // не то что вы думаете
19: cout << "nintOne:t" << intOne << endl;
20: cout << "intTwo:t" << intTwo << endl;
21: cout << "rSomeRef:t" << rSomeRef << endl;
22: cout << "&intOne:t" << &intOne << endl;
23: cout << "&intTwo:t" << &intTwo << endl;
24: cout << "&rSomeRef:t" << &rSomeRef << endl;
25: return 0;
26: }
Результат:
intOne: 5
rSomeRef: 5
&intOne: 0x213e
&rSomeRef: 0x213e
intOne: 8
int:Two: 8
rSomeRef: 8
&intOne: 0x213e
&intTwo: 0x2130
&rSomeRef: 0x213e
Анализ: Вновь в строках 8 и 9 объявляются целочисленная переменная и ссылка на целое значение. В строке 11 целочисленной переменной присваивается значение 5, а в строках 12-15 выводятся значения переменной и ссылки, а также их адреса.
В строке 17 создается новая переменная intTwo, которая тут же инициализируется значением 8. В строке 18 программист пытается переназначить ссылку rSomeRef так, чтобы она стала псевдонимом переменной intTwo, но этого не происходит. На самом же деле ссылка rSomeRef продолжает действовать как псевдоним переменной intOne, поэтому такое присвоение эквивалентно следующей операции:
intOne = intTwo;
Это кажется достаточно убедительным, особенно при выводе на экран значений переменной intOne и ссылки rSomeRef (строки 19— 21): их значения совпадают со значением переменной intTwo. На самом деле при выводе на экран адресов в строках 22—24 вы видите, что ссылка rSomeRef продолжает ссылаться на переменную intOne, а не на переменную intTwo.
Не рекомендуется:Не пытайтесь переназначить ссылку. Не путайте оператор адреса с оператором ссылки.
Рекомендуется:Используйте ссылки для создания псевдонимов объектов. Инициализируйте ссылки при объявлении.
На что можно ссылаться
Ссылаться можно на любой объект, включая нестандартные (определенные пользователем) объекты. Обратите внимание, что ссылка создается на объект, а не на класс. Нельзя объявить ссылку таким образом:
int & rIntRef = int; // неверно
Ссылку rIntRef нужно инициализировать, используя конкретную целочисленную переменную, например:
int howBig = 200: int & rIntRef = howBig;
Точно так же нельзя инициализировать ссылку классом CAT:
CAT & rCatRef = CAT; // неверно
Ссылку rCatRef нужно инициализировать, используя конкретный объект класса CAT:
CAT frisky;
CAT & rCatRef = frisky;
Ссылки на объекты используются точно так же, как сами объекты. Доступ к данным-членам и методам осуществляется с помощью обычного оператора доступа к членам класса (.), и, подобно встроенным типам, ссылка действует как псевдоним для объекта. Этот факт иллюстрируется в листинге 9.4.
Листинг 9.4. Ссылки на объекты класса
1: // Листинг 9.4.
2: // Ссылки на объекты класса
3:
4: #include <iostream.h>
5:
6: class SimpleCat
7: {
8: public:
9: SimpleCat(int age, int weight);
10: ~SimpleCat() {}
11: int GetAge() { return itsAge; }
12: int GetWeight() { return itsWeight; }
13: private:
14: int itsAge;
15: int itsWeight;
16: }
17:
18: SimpleCat::SimpleCat(int age, int weight)
19: {
20: itsAge = age;
21: itsWeight = weight;
22: }
23:
24: int main()
25: {
26: SimpleCat Fnsky(5,3);
27: SimpleCat & rCat = Fnsky;
28:
29: cout << "Frisky: ";
30: cout << Frisky.GetAge() << " years old. n";
31: cout << "И Frisky весит: ";
32: cout << rCat.GetWeight() << " kilograms. n";
33: return 0;
34: }
Результат:
Frisky: 5 years old.
И Frisky весит: 3 kilograms.
Анализ: В строке 26 объявляется переменная Frisky в качестве объекта класса SimplcCat. В строке 27 объявляется ссылка rCat на некоторый объект класса SimpleCat, и эта ссылка инициализируется с использованием уже объявленного объекта Frisky. В строках 30 и 32 вызываются методы доступа к членам класса SimpleCat, причем сначала это делается с помощью объекта класса SimpleCat (Frisky), а затем с помощью ссылки на объект класса SimpleCat (rCat). Обратите внимание, что результаты идентичны. Снова повторюсь: ссылка — это всего лишь псевдоним реального объекта.
Объявление ссылок
Ссылка объявляется путем указания типа данных, за которым следует оператор ссылки (&) и имя ссылки. Ссылки нужно инициализировать при объявлении.
Пример 1:
int hisAge;
int &rAge = hisAge;
Пример 2:
CAT boots;
CAT &rCatRef = boots;
Нулевые указатели и нулевые ссылки
Когда указатели не инициализированы или когда они освобождены, им следует присваивать нулевое значение (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() указателями на исходные значения или передать ссылки на исходные значения.
