T& як аліас: посилання має бути привʼязане до обʼєкта

1. T& як аліас: посилання має бути привʼязане до обʼєкта

Посилання T&: навіщо вони потрібні й як про них думати

Коли ви тільки починаєте писати програми, здається, що звичайних змінних цілком достатньо: створили int x = 10;, змінили, вивели — і все чудово. Потім зʼявляються функції та контейнери, і раптом виникає запитання: «А можна я передам у функцію обʼєкт так, щоб вона працювала з тим самим обʼєктом, а не з його копією?»

Вказівники теж це вміють, але з ними треба бути обережними: перевіряти nullptr, не забувати *, не розіменовувати «порожнечу». Посилання T& — це спосіб сказати: «у мене є обʼєкт, він точно існує, і я хочу дати йому друге імʼя». У тексті стандарту навіть трапляється формулювання «reference binds to an expression».

T& — це аліас, а не окремий обʼєкт

Посилання в C++ — це не «коробочка, де лежить значення» і не «вказівник, тільки красивіший». Для початку найзручніше мислити так: посилання — це друге імʼя вже наявного обʼєкта. Обʼєкт один, а імен у нього може стати два або більше.

Це схоже на ситуацію, коли людина має імʼя в паспорті й прізвисько: людина одна й та сама, просто звертатися до неї можна по-різному.

Подивімося на найпростіший приклад:

#include <iostream>

int main() {
    int x = 10;
    int& r = x;      // r — аліас (друге імʼя) для x
    r += 5;          // змінюємо x через r

    std::cout << x << '\n'; // 15
}

Тут варто зупинитися й прямо проговорити це вголос (можна пошепки, щоб компілятор не почув): r — це не копія x. Це доступ до того самого x. Тому r += 5; змінює x.

Посилання потрібно ініціалізувати одразу

Після знайомства з вказівниками новачкам часто хочеться зробити так: «Зараз оголошу посилання, а потім вирішу, до чого його привʼязати». У C++ так не можна — і, чесно кажучи, це навіть добре. Сенс посилання T& саме в тому, що воно не може бути «порожнім».

Неправильно:

int main() {
    int& r;          // помилка компіляції: посилання без обʼєкта
}

Правильно — тільки так:

#include <iostream>

int main() {
    int x = 1;
    int& r = x;      // привʼязали одразу

    std::cout << r << '\n'; // 1
}

Чому це так важливо? Бо сенс посилання саме в тому, що воно завжди вказує на наявний обʼєкт. Якби посилання можна було оголосити порожнім, тоді довелося б вигадувати, як перевіряти його на «порожнечу», як у nullptr. Але тоді це вже був би вказівник.

C++ не ідеальний, але в цьому місці він чесний: хочете «може бути відсутнім» — беріть вказівник. Хочете «обовʼязково є» — беріть посилання.

Посилання не перепривʼязується

Ще одна типова ментальна пастка після знайомства з посиланнями: здається, що якщо написати r = інше, то посилання почне посилатися на «інше». Але в C++ оператор = для посилання не змінює привʼязку. Він змінює обʼєкт, до якого посилання вже привʼязане.

Подивімося:

#include <iostream>

int main() {
    int a = 1;
    int b = 2;

    int& r = a;      // r — аліас для a
    r = b;           // це a = b (копіюємо значення), НЕ перепривʼязування

    std::cout << "a=" << a << " b=" << b << '\n'; // a=2 b=2
}

Після r = b; у вас a стане дорівнювати b. Але r однаково залишиться посиланням на a. Якщо потім зробити r = 100;, зміниться a, а не b.

Ця особливість спочатку дратує. Потім ви до неї звикаєте. А далі починаєте цінувати її, бо «перепривʼязувані посилання» дуже швидко перетворилися б на хаос, у якому одне імʼя раптом починає вказувати на інший обʼєкт.

Адреса посилання збігається з адресою обʼєкта

Після теми про вказівники логічно перевірити: «А що буде, якщо взяти адресу посилання?» І ось тут зручно ще раз закріпити модель аліаса: якщо r — це просто інше імʼя x, то адреса має бути одна й та сама.

#include <iostream>

int main() {
    int x = 7;
    int& r = x;

    std::cout << std::boolalpha << (&x == &r) << '\n'; // true
}

Тут &x — адреса обʼєкта x. А &r — по суті теж адреса обʼєкта x, бо r — це той самий обʼєкт.

Це корисно памʼятати, коли ви читаєте чужий код: наявність посилання не створює «другого обʼєкта в памʼяті». Це все той самий обʼєкт, просто доступ до нього ви отримуєте через інше імʼя.

Змінна, вказівник і посилання: мінішпаргалка

Коли інформації стає забагато, мозок новачка починає робити вигляд, що він «усе зрозумів», хоча насправді просто втомився. Тому корисно тримати під рукою маленьку таблицю-інтуїцію. Поки що без тонкощів — тільки те, що потрібно сьогодні.

int x = 5;

int* p = &x;

p = &y;

*p

int& r = x;

Ця таблиця — ваш «швидкий компас». Якщо в задачі обʼєкт може бути відсутній, посилання не підходить. Якщо ж обʼєкт обовʼязковий і ви хочете працювати з ним напряму, посилання підходить ідеально.

2. Посилання на практиці: робота з контейнерами та значеннями

Змінюємо елемент std::vector «на місці» через посилання

Щоб посилання перестало бути абстракцією, привʼяжімо його до чогось знайомого: std::vector. Уявімо, що протягом курсу ми пишемо простий консольний застосунок «Список задач». У нас є вектор рядків, і ми хочемо змінити задачу за індексом.

Без посилань тут часто роблять так: беруть елемент, створюють копію, змінюють її — і дивуються, що вектор не змінився. Саме тут добре видно різницю між копією та аліасом.

Поганий (але дуже поширений) варіант: випадкова копія

#include <iostream>
#include <string>
#include <vector>

int main() {
    std::vector<std::string> tasks{"buy milk", "learn c++"};

    std::string t = tasks[0]; // копія!
    t += " ASAP";

    std::cout << tasks[0] << '\n'; // buy milk
}

Ви змінили t, але tasks[0] залишився незмінним, бо t — окремий обʼєкт.

Правильний варіант: посилання на елемент

#include <iostream>
#include <string>
#include <vector>

int main() {
    std::vector<std::string> tasks{"buy milk", "learn c++"};

    std::string& t = tasks[0]; // посилання на елемент (аліас)
    t += " ASAP";              // змінюємо сам елемент вектора

    std::cout << tasks[0] << '\n'; // buy milk ASAP
}

Ось тут посилання виконує роль «ручки» до вже наявного обʼєкта. І це справді базова навичка під час читання C++-коду: побачити T& і зрозуміти: «ага, тут не копія, тут робота з оригіналом».

Чому в T& немає nullptr і перевірок

Після вказівників рука так і тягнеться написати щось на кшталт:

// так НЕ роблять, і це не скомпілюється
if (r != nullptr) { ... }

Посилання не може бути nullptr. Воно не має стану «не вказує нікуди». Тому й таких перевірок немає.

Натомість тип дає вам дуже сильну гарантію: якщо функція приймає std::string&, то вона ніби каже: «Я очікую реальний рядок — не порожнечу, не щось умовне, а звичайний обʼєкт».

Саме тут формується важлива звичка: тип — це частина змісту. Якщо ви хочете виразити «обʼєкта може не бути», не намагайтеся «хитрувати» посиланнями. Використовуйте вказівник (або інші механізми, але про них — пізніше).

Ще трохи практики: «друге імʼя» для чисел і рядків

Щоб не здавалося, ніби посилання потрібні лише для std::vector, закріпімо все на простих типах, де ефект максимально прозорий.

Зміна через посилання змінює початкову змінну:

#include <iostream>

int main() {
    int score = 10;
    int& alias = score;

    alias = 42; // змінюємо score через alias
    std::cout << score << '\n'; // 42
}

Два аліаси для одного обʼєкта:

#include <iostream>

int main() {
    int x = 5;
    int& a = x;
    int& b = x;

    a += 1;
    b += 2;

    std::cout << x << '\n'; // 8
}

Іноді це виглядає як магія, але насправді все чесно: обʼєкт один, і всі операції виконуються над ним.

3. Присвоювання через посилання: що означає r = b;

Ось формулювання, яке корисно тримати в голові, коли ви читаєте чужі функції й намагаєтеся зрозуміти, «хто кого змінює»:

T& у C++ — це імʼя, яке має бути привʼязане до наявного обʼєкта і залишається привʼязаним до нього до кінця своєї області видимості.

Якщо спростити ще більше: посилання привʼязується до обʼєкта лише один раз.

Саме тому посилання — чудовий інструмент, щоб дати обʼєкту друге імʼя, але поганий — щоб «перекидати ручку» між обʼєктами. Для цього є вказівники.

Мінісхема: що відбувається за r = b

Часто плутанина виникає навколо рядка r = b;. Давайте візуалізуємо, що саме відбувається.

flowchart TD
    A["int a = 1;"] --> B["int b = 2;"]
    B --> C["int& r = a; (r — аліас для a)"]
    C --> D["r = b;"]
    D --> E["a отримує значення b"]
    E --> F["r і далі залишається аліасом для a"]

Тобто на кроці r = b; змінюється значення a, а не «налаштування r».

4. Типові помилки під час роботи з посиланнями

Помилка № 1: намагатися оголосити посилання без ініціалізації.
Зазвичай це тягнеться зі звички до змінних: «оголошу зараз, заповню потім». Але посилання має іншу природу: воно не про «майбутнє значення», а про доступ до вже наявного обʼєкта. Тому int& r; — це не «поки порожньо», а просто неможливий стан. Правильна стратегія — або ініціалізувати посилання одразу, або використати інший інструмент, наприклад вказівник, якщо вам справді потрібен стан «поки не знаю».

Помилка № 2: очікувати, що r = b; перепривʼяже посилання.
Мозок бачить = і думає: «перепризначення». Але в C++ у посилання такого механізму немає: воно не вміє «перемикатися» на інший обʼєкт. Якщо ви бачите r = b;, читайте це так: «присвоїти обʼєкту, на який посилається r, значення b». Допомагає звичка подумки замінювати r на alias(a).

Помилка № 3: намагатися створити «посилання, яке може бути відсутнім».
Новачки іноді хочуть, щоб посилання було «як вказівник, але без *». І тоді починаються пошуки трюків, милиць і темної магії. У навчальному й прикладному коді це майже завжди шлях до незрозумілих багів. Якщо обʼєкт може бути відсутнім, це контракт «може бути порожньо», і його краще виражати через вказівник і nullptr. Посилання ж має означати: «обʼєкт існує».

Помилка № 4: втрачати межу між копією та посиланням під час роботи з контейнерами.
Дуже поширена ситуація: auto x = v[i]; — це копія, а потім ви змінюєте x і чекаєте, що зміниться v[i]. Ні, не зміниться. Якщо ви хочете змінювати елемент контейнера, вам потрібне посилання: auto& x = v[i]; (або явно T&). Сьогодні ми це побачили на рядках зі списку задач: різниця буквально в одному символі, а ефект — ніби з іншого світу.

Помилка № 5: створювати посилання на обʼєкт, який скоро зникне з області видимості.
Цю тему ми розберемо глибше пізніше, але базову обережність варто ввімкнути вже зараз: посилання має жити не довше за обʼєкт. Якщо ви привʼязали посилання до змінної з внутрішнього блока { ... }, а потім вийшли з нього, далі посиланню вже «нікуди посилатися». Навіть якщо компілятор промовчить, програма може почати поводитися дивно. Краще одразу тримати в голові правило: «посилання не повинно пережити обʼєкт».

1

Опитування

Вказівники і посилання, рівень 39, лекція 4

Недоступний

Вказівники і посилання

Вказівники і посилання

Відкрити