Ми з вами вже ознайомилися із звичайними змінними та вказівниками. Тепер, нам слід, ознайомитися ще з одним «інструментом» мови С++.

Посилання можна порівняти із псевдонімом. Тобто, уявіть ситуацію. Ви маєте якусь змінну з довгим ім’ям або вам потрібно використовувати якусь змінну із структури. При цьому, використовувати такі змінні доводиться доволі часто. То, ви можете створити посилання на ці змінні яке буде коротше в записі і використовувати його. Посилання за своїм принципом роботи схожі на вказівники (в реальності, посилання реалізовані за допомогою вказівників).

Для того щоб створити посилання вам необхідно:

Зауважте, ми відразу надаємо якесь значення посиланню. Це має бути саме змінна, а не число, символ і так далі. Посилання мають бути ініціалізованими відразу при створені.

При цьому, посилання не можуть змінювати свого значення. Тобто, ви не зможете створити посилання на одну змінну, а потім зробити його на іншу. Адже, псевдонім одного письменника не може стати псевдонімом іншого. По тій же причині посилання не може бути порожнім.

Створення посилання виглядатиме так:

        Тип_посилання & ім’я_посилання = ім’я_змінної_на_яку_робимо_посилання;
        

При цьому, щоб використати посилання достатньо вказати лише його ім’я.

Розглянемо це на прикладі:

    
            #include <iostream>

            int main()
            {
                int a = 8;

                //створюємо посилання "b" на змінну "а"
                int& b = a;

                //перевіряємо яке значення буде мати посилання
                //зверніть увагу, що для використання ми вказуємо
                //лише ім'я посилання
                std::cout << "b = " << b << std::endl;

                //вказуємо для посилання нове значення.
                //важливо! не посилання на нову змінну, а саме значення
                b = 23;

                //оскільки, змінна та посилання на неї це одне і теж,
                //то значення змінної "а" тепер буде "23"
                std::cout << "a = " << a << std::endl;

                return 0;
            }
        

Змінна та посилання на неї дійсно є одним і тим же. Наприклад, якщо ви спробуєте отримати адресу посилання, то отримаєте адресу змінної на яку йде посилання. Ви можете добавити наступний код до попередньої програми та переконатися в цьому.

    
            //адреса змінної "а"
            std::cout << "&a = " << &a << std::endl;

            //адреса посилання "b" на змінну "а"
            std::cout << "&b = " << &b << std::endl;
        

Якщо, початкова змінна є константною, то ваше посилання також має бути константним. Але, якщо, початкова змінна є не константною, то посилання на неї може бути як константним так і не константним. Пам’ятаємо, щоб створити константну змінну потрібно написати ключове слово «const» перед типом змінної.

    
            //створюємо не константну змінну
            int a = 8;

            //відповідно, для неї можна створити:
            //константне посилання "b" на змінну "а"
            const int& b = a;

            //не константне посилання "с" на змінну "а"
            int& c = a;

            //створюємо константну змінну "d"
            const int d = 12;

            //для неї можна створити константне посилання
            const int& e = d;

            //константному посиланню можна надати значення
            //яке не є змінною
            const int& a = 7;
        

Також, ви можете використовувати посилання в якості аргументу функції. В такій ситуації ви зможете змінювати значення змінної яку передаєте у функцію. Це буде працювати як і вказівник.

Для того щоб створити посилання в якості аргументу функції необхідно:

Щоб передати змінну в якості аргумента функції на місце посилання достатньо лише вказати ім’я цієї змінної. Звісно, ж ця змінна має бути такого ж типу як і аргумент.

Ви не можете передати в не константне посилання число, символ чи будь-яке інше значення. Це має бути саме змінна! При цьому, не константне посилання не може мати значення за замовчуванням.

Посилання в якості аргументу функції використовують з такою ж ціллю як і вказівник. Тобто, для того щоб отримати доступ до значення змінної на пряму. Тому, якщо ви зміните значення аргументу, то зміните і значення самої змінної яку передавали.

Наприклад:

    
            #include <iostream>

            //створюємо функцію в якості аргументу якої
            //виступає посилання
            void fun(int& b)
            {
                std::cout << "input number: " << std::endl;

                //оскільки посилання має доступ на пряму до значення,
                //то змінивши значення посилання ("b") ми змінимо
                //значення змінної яку передали у функцію
                std::cin >> b;
            }

            int main()
            {
                //створюємо змінну зі значенням "8"
                int a = 8;

                //передаємо нашу змінну у функцію яка використовує
                //посилання в якості аргументу, тому наша
                //змінна "а" змінить своє значення, якщо ми змінимо
                //його в середині даної функції
                fun(a);

                //дивимося на значення нашої змінної "а"
                std::cout << a << std::endl;

                return 0;
            }
        

Якщо, ви хочете щоб ваше значення залишилося не змінним, то створюйте константне посилання:

        void fun(const int& b)
        

Якщо ви використовуєте константне посилання в якості аргументу функції, то ви можете надати йому значення за замовчуванням. Також, такому аргументу ви можете передавати звичайне значення.

    
            #include <iostream>

            //враховуючи, що посилання є константним, то
            //йому можна надати значення за замовчуванням
            void fun(const int& a = 3)
            {
                std::cout << a << std::endl;
            }

            int main()
            {
                //і в якості аргумента функції можна передавати
                //значення, а не якусь змінну
                fun(7);

                return 0;
            }
        

Як вже було написано раніше, що посилання це є як псевдонім. Наприклад, ви можете мати якусь змінну яка належить структурі і при цьому вам доводиться дуже часто використовувати дану змінну. Щоб кожного разу не записувати весь шлях до цієї змінної, то можна створити посилання на неї. Після чого використовувати його.

    
            #include <iostream>

            //створимо якусь структуру
            struct A
            {
                //в ній буде знаходитися необхідна нам змінна
                int age;
            };

            struct B
            {
                //цю структуру помістимо в середину іншої структури
                //для того, щоб шлях до змінної був довшим.
                //це необхідно для кращого розуміння
                A a;
                int number;
            };

            int main()
            {
                B b;

                //як бачите, щоб добратися до змінної "age"
                //потрібно вказати доволі довгий шлях
                b.a.age = 4;

                std::cout << b.a.age << std::endl;

                //створимо посилання на змінну "age".
                //для цього вказуємо весь шлях до неї
                int& c = b.a.age;

                //змінюємо значення посилання
                c = 7;

                //відповідно і значення нашої змінної теж зміниться
                std::cout << b.a.age << std::endl;

                return 0;
            }
        

Посилання по факту є спрощеним вказівником. Зазвичай його використовують коли необхідний прямий доступ до значення змінних. Звісно, ви можете не забивати цим голову. Адже, робота із вказівниками є набагато важливіша. Вказівники мають більший функціонал. Але, в якості альтернативи для не складних задач чи як аргумент функції зручно використовувати посилання.