Перевантаження операторів: методи класу та спеціальні оператори

Від бінарних до унарних: нова категорія операторів

У попередній статті ми вивчили перевантаження бінарних операторів — операторів із двома операндами (a + b, a < b, std::cout << a). Ці оператори природно реалізовувати як friend-функції, бо обидва операнди мають рівну роль.

Але C++ має і унарні оператори — оператори з одним операндом. Також є спеціальні оператори, що працюють зовсім інакше: оператор індексації [], оператор виклику функції (), оператори присвоювання =, +=, -=. Ці оператори тісно пов'язані з об'єктом, що стоїть зліва, тому їх природно реалізовувати як методи класу.

Розглянемо клас Counter — простий лічильник, що демонструє всі категорії операторів:

#include <iostream>

class Counter
{
private:
    int value;

public:
    Counter(int v = 0) : value(v) {}

    int getValue() const
    {
        return value;
    }

    void print() const
    {
        std::cout << "Counter: " << value;
    }
};

int main()
{
    Counter count(5);

    count.print();
    std::cout << "\n";

    // ❌ Хочемо писати:
    // count++;        // Інкремент
    // -count;         // Унарний мінус
    // count[0];       // Індексація (якщо це масив лічильників)
    // count(10);      // Виклик як функції

    // Але без перевантаження це не працює

    return 0;
}

Давайте навчимо клас Counter розуміти ці оператори.

Механізм компіляції та неявний покажчик this

Коли компілятор C++ зустрічає вираз із оператором, він намагається знайти відповідну функцію за двома правилами перетворення:

1. Як метод лівого операнда: вираз a @ b перетворюється на виклик a.operator@(b).
2. Як глобальну або дружню функцію: той самий вираз перетворюється на operator@(a, b).

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

• Бінарний оператор-метод приймає лише один параметр (правий операнд), оскільки лівий операнд передається автоматично як неявний покажчик ClassName* const this.
• Унарний оператор-метод взагалі не приймає параметрів, оскільки його єдиним операндом і є сам об'єкт *this.

Це фундаментальне правило визначає архітектурний вибір способу перевантаження. Якщо операція є симетричною (наприклад, додавання a + b, де операнди можуть мінятися місцями або лівий операнд може бути примітивним числом на зразок 5 + counter), її реалізують через дружні функції. Якщо ж операція змінює внутрішній стан об'єкта (+=, =, ++) або концептуально належить самому об'єкту ([], (), ->), мовний стандарт C++ вимагає або наполегливо рекомендує реалізовувати її виключно як метод класу.

Унарні оператори: -, !, ~

Унарні оператори мають один операнд. Найпоширеніші:

• Унарний мінус (-a) — негація числа
• Логічне НЕ (!a) — інверсія булевого значення
• Побітове НЕ (~a) — інверсія бітів (рідко використовується для класів)

Унарні оператори перевантажуються як const-методи без параметрів:

#include <iostream>

class Counter
{
private:
    int value;

public:
    Counter(int v = 0) : value(v) {}

    int getValue() const { return value; }

    // Унарний мінус: повертає новий Counter із від'ємним значенням
    Counter operator-() const
    {
        return Counter(-value);
    }

    // Логічне НЕ: повертає true, якщо лічильник дорівнює 0
    bool operator!() const
    {
        return value == 0;
    }

    void print() const
    {
        std::cout << "Counter: " << value;
    }
};

int main()
{
    Counter count(5);
    Counter zero(0);

    std::cout << "Original: ";
    count.print();
    std::cout << "\n";

    // Унарний мінус
    Counter negated = -count;
    std::cout << "Negated: ";
    negated.print();
    std::cout << "\n";

    // Логічне НЕ
    if (!zero)
    {
        std::cout << "Zero counter is empty (evaluates to true)\n";
    }

    if (!count)
    {
        std::cout << "This won't print\n";
    }
    else
    {
        std::cout << "Non-zero counter is not empty\n";
    }

    return 0;
}

Рядки 14–17: operator-() — const-метод без параметрів. Створює новий Counter із від'ємним значенням. Вираз -count компілятор перетворює на count.operator-().

Рядки 20–23: operator!() повертає bool. Логіка: лічильник дорівнює нулю — це «порожній» стан, що логічно інтерпретується як false. Тому !zero дає true.

Рядок 43: вираз -count створює анонімний тимчасовий об'єкт Counter(-5), який присвоюється змінній negated.

Чому унарний мінус повертає копію, а не посилання?

Студенти часто запитують: «Якщо повернення за посиланням працює швидше й уникає копіювання, чому ми не повертаємо Counter&?».

У мові C++ повернення посилання з унарного мінуса є грубою помилкою з двох причин:

1. Математична семантика операції: У математиці та мовах програмування вираз -x обчислює нове від'ємне значення, але ніколи не змінює значення самої змінної x. Якщо метод повертатиме посилання на поточний об'єкт *this, йому доведеться мутувати поле value:

   // ❌ ПОМИЛКОВА СЕМАНТИКА: змінює вихідний об'єкт
   Counter& operator-()
   {
       value = -value;
       return *this;
   }
   

   У такому разі вираз Counter b = -a; призведе до того, що значення a непомітно зміниться на протилежне, що суперечить принципам роботи мови.
2. Загроза висячого посилання (dangling reference): Якщо метод створює новий об'єкт всередині тіла функції для збереження результату, цей об'єкт розташовується у локальному стековому кадрі функції:

   // ❌ КАТАСТРОФА ПАМ'ЯТІ: повернення посилання на локальну змінну
   Counter& operator-() const
   {
       Counter temp(-value);
       return temp; // ⚠️ temp знищується у момент виходу з функції!
   }
   

   Під час виходу з методу локальна змінна temp негайно знищується її деструктором. Посилання, яке повертається назовні, вказує на очищену область стека. Будь-яка спроба прочитати цей результат призводить до невизначеної поведінки (undefined behavior) та непередбачуваних збоїв програми.

Тому унарний мінус завжди повертає новий об'єкт за значенням (Counter). Сучасні компілятори застосовують оптимізацію повернення значення (Return Value Optimization / RVO), тому передача нового об'єкта відбувається без зайвих витрат пам'яті.

Обов'язковість специфікатора const

Зверніть увагу на сигнатуру методу:

Counter operator-() const;
bool operator!() const;

Специфікатор const у кінці заголовка методу є обов'язковим стандартом проектування. Він повідомляє компілятору, що метод гарантує незмінність стану об'єкта *this.

Якщо забути вказати const, ці методи неможливо буде викликати для константних екземплярів або тимчасових об'єктів:

const Counter fixedCounter(42);
// Counter negated = -fixedCounter; // ❌ Помилка компіляції, якщо operator- не має const!

Константні методи розширюють гнучкість коду, дозволяючи використовувати об'єкти в операціях «тільки для читання».

Побітове НЕ (~): робота з бітовими прапорцями

Оператор побітового заперечення ~ інвертує двійкові розряди числа (нулі стають одиницями, а одиниці — нулями). Для користувацьких класів його найчастіше перевантажують, коли об'єкт представляє бітову маску, набір прав доступу або прапорців стану:

#include <iostream>

class Permissions
{
private:
    unsigned char mask; // Бітова маска дозволів (читання, запис, виконання)

public:
    explicit Permissions(unsigned char m = 0) : mask(m) {}

    unsigned char getMask() const { return mask; }

    // Побітове НЕ: інвертує всі дозволи
    Permissions operator~() const
    {
        return Permissions(static_cast<unsigned char>(~mask));
    }
};

int main()
{
    // Нехай біт 0 відповідає за читання (0b00000001 = 1)
    Permissions readOnly(1);

    // Інвертуємо маску: забороняємо читання, дозволяємо все інше
    Permissions inverted = ~readOnly;

    std::cout << "Original mask: " << static_cast<int>(readOnly.getMask()) << "\n";
    std::cout << "Inverted mask: " << static_cast<int>(inverted.getMask()) << "\n";

    return 0;
}

Інкремент та декремент: ++ та --

Оператори інкременту (++) та декременту (--) існують у двох формах:

• Префіксна (++a, --a) — збільшує/зменшує значення, повертає посилання на змінений об'єкт
• Постфіксна (a++, a--) — збільшує/зменшує значення, повертає копію старого стану

Компілятор розрізняє ці форми за сигнатурою:

// Префіксна форма: без параметрів, повертає посилання
Counter& operator++();      // ++count

// Постфіксна форма: фіктивний параметр int, повертає копію
Counter operator++(int);    // count++

Фіктивний параметр int у постфіксній формі — це маркер для компілятора, а не реальний аргумент. Його значення не використовується.

#include <iostream>

class Counter
{
private:
    int value;

public:
    Counter(int v = 0) : value(v) {}

    int getValue() const { return value; }

    // === Префіксний інкремент (++count) ===
    Counter& operator++()
    {
        ++value;        // Збільшуємо значення
        return *this;   // Повертаємо посилання на себе
    }

    // === Постфіксний інкремент (count++) ===
    Counter operator++(int)
    {
        Counter temp(*this);  // Зберігаємо копію поточного стану
        ++(*this);            // Викликаємо префіксну версію
        return temp;          // Повертаємо старий стан
    }

    // === Префіксний декремент (--count) ===
    Counter& operator--()
    {
        --value;
        return *this;
    }

    // === Постфіксний декремент (count--) ===
    Counter operator--(int)
    {
        Counter temp(*this);
        --(*this);
        return temp;
    }

    void print() const
    {
        std::cout << "Counter: " << value;
    }
};

int main()
{
    Counter count(5);

    std::cout << "Initial: ";
    count.print();
    std::cout << "\n";

    // Префіксний інкремент: збільшує і повертає нове значення
    ++count;
    std::cout << "After ++count: ";
    count.print();
    std::cout << "\n";

    // Постфіксний інкремент: збільшує, але повертає старе значення
    Counter old = count++;
    std::cout << "After count++, old: ";
    old.print();
    std::cout << ", current: ";
    count.print();
    std::cout << "\n";

    // Префіксний декремент
    --count;
    std::cout << "After --count: ";
    count.print();
    std::cout << "\n";

    // Постфіксний декремент
    Counter old2 = count--;
    std::cout << "After count--, old: ";
    old2.print();
    std::cout << ", current: ";
    count.print();
    std::cout << "\n";

    return 0;
}

Рядки 14–18: префіксний operator++() збільшує value і повертає *this (посилання на поточний об'єкт). Це ефективно — без копіювання.

Рядки 21–26: постфіксний operator++(int) зберігає копію старого стану у temp, викликає префіксну версію для збільшення, повертає temp. Це менш ефективно через копіювання.

Рядок 24: ++(*this) викликає префіксну версію operator++() для поточного об'єкта. Уникаємо дублювання коду.

Рядки 67–68: Counter old = count++ демонструє різницю: count збільшується до 7, але old отримує старе значення 6.

Внутрішня механіка: чому префікс повертає посилання, а постфікс — значення?

Різниця в типах повернення між префіксною та постфіксною формами обумовлена фундаментальними правилами керування пам'яттю та семантикою мови C++:

1. Префіксна форма (++count): семантика l-value та ланцюгові виклики. Префіксний інкремент спочатку змінює стан об'єкта, а потім повертає його самого. Повернення за посиланням Counter& повертає сам об'єкт *this, який є повноцінним l-value (об'єктом, що має фіксовану адресу в пам'яті). Це дозволяє безпечно будувати послідовні ланцюжки:

   ++++count; // Працює коректно: спочатку збільшує count, потім знову збільшує його ж
   

   
   Якби префіксний оператор повертав значення за копією (Counter), вираз ++++count створив би проміжну тимчасову копію, яку збільшив би вдруге, тоді як оригінальний count збільшився б лише один раз. Повернення посилання гарантує, що всі операції застосовуються безпосередньо до оригінального об'єкта в пам'яті без жодних накладних витрат на копіювання.
2. Постфіксна форма (count++): неможливість повернення посилання. Контракт постфіксного оператора вимагає: «збільш об'єкт, але поверни те значення, яке він мав ДО збільшення». Оскільки сам екземпляр *this вже отримав нове значення, попередній стан існує виключно у локальній тимчасовій змінній temp:

   Counter operator++(int)
   {
       Counter temp(*this); // 1. Зберігаємо старий стан
       ++(*this);           // 2. Збільшуємо оригінал
       return temp;         // 3. Повертаємо копію старого стану
   }
   

   
   Спроба повернути Counter& на temp була б фатальною помилкою: після завершення виконання методу стек очищається, змінна temp знищується, а повернене посилання стає висячим посиланням (dangling reference). Саме тому постфіксний оператор зобов'язаний повертати результат виключно за значенням.
3. Фіктивний параметр int як синтаксичний маркер. Префіксний і постфіксний інкременти мають однакове ім'я функції — operator++. Щоб система перевантаження функцій C++ могла розрізнити їх на етапі аналізу типів, розробники мови додали фіктивний неіменований параметр int у постфіксний варіант. Під час виклику виразу count++ компілятор автоматично перетворює його на count.operator++(0). Значення аргументу 0 ніколи не використовується в коді — воно слугує лише сигналом для компілятора.
4. Виклик ++(*this): принцип єдиного джерела правди. У постфіксній формі замість дублювання коду ++value викликається префіксний оператор ++(*this). Це гарантує, що вся логіка інкременту (перевірки меж, нормалізація, додаткові дії) зосереджена в одному місці.

@startuml
skinparam style plain
skinparam backgroundColor #FFFFFF
skinparam sequenceMessageAlign center

actor "Клієнтський код" as Client #DBEAFE
participant "Об'єкт Counter (*this)" as Obj #DCFCE7
participant "Стек / Тимчасова копія" as Stack #FEF3C7

== Префіксний інкремент (++count) ==
Client -> Obj : operator++()
Obj -> Obj : ++value (модифікація на місці)
Obj --> Client : повертає *this за посиланням (Counter&)
note over Client, Obj #DCFCE7
  Нульове копіювання пам'яті.
  Клієнт отримує прямий доступ до того ж об'єкта.
end note

== Постфіксний інкремент (count++) ==
Client -> Obj : operator++(0)
Obj -> Stack : Counter temp(*this) [створення копії]
Obj -> Obj : ++(*this) [збільшення оригіналу]
Obj --> Client : повертає temp за значенням (копія)
Stack -> Stack : знищення локального temp
note over Client, Stack #FEF3C7
  Створюється тимчасовий об'єкт на стеку.
  Витрати на конструктор копіювання та деструктор.
end note
@enduml

Чому в інженерному коді та STL віддають перевагу ++i замість i++

У циклах зі стандартними типами (int, size_t) сучасні оптимізатори компілятора зазвичай здатні прибрати зайве копіювання постфіксного інкременту. Проте для користувацьких класів та ітераторів стандартної бібліотеки шаблонів (STL) різниця є критичною.

Розглянемо стандартний цикл обходу контейнера:

// ❌ Менш ефективно для важких ітераторів:
for (auto it = container.begin(); it != container.end(); it++) { ... }

// ✅ Рекомендований стандарт мови C++:
for (auto it = container.begin(); it != container.end(); ++it) { ... }

Ітератори складних асоціативних контейнерів (наприклад, std::map, std::unordered_map або std::set) під капотом містять складні структури даних: покажчики на вузли червоно-чорного дерева, індекси бакетів хеш-таблиці або глибину стека обходу. Кожен виклик it++ створює повноцінну копію об'єкта ітератора, ініціалізує її поля, а наприкінці виразу викликає деструктор. У циклі на мільйон ітерацій це створює мільйон абсолютно непотрібних копіювань і руйнувань об'єктів.

Оператор індексації: []

Оператор індексації [] дозволяє звертатися до елементів контейнера як до масиву: array[i]. Щоб підтримувати як читання, так і запис, потрібно дві версії оператора:

1. Не-const версія — повертає тип& (посилання), дозволяє модифікацію
2. Const версія — повертає const тип& або тип, дозволяє лише читання

#include <iostream>
#include <cassert>

class IntArray
{
private:
    int data[10];
    int size;

public:
    IntArray() : size(10)
    {
        for (int i = 0; i < size; ++i)
        {
            data[i] = 0;
        }
    }

    int getSize() const { return size; }

    // Не-const версія: дозволяє запис array[i] = value
    int& operator[](int index)
    {
        assert(index >= 0 && index < size && "Index out of bounds");
        return data[index];
    }

    // Const версія: дозволяє читання з const об'єктів
    const int& operator[](int index) const
    {
        assert(index >= 0 && index < size && "Index out of bounds");
        return data[index];
    }
};

int main()
{
    IntArray array;

    // Запис через не-const версію
    array[0] = 10;
    array[1] = 20;
    array[5] = 50;

    std::cout << "array[0] = " << array[0] << "\n";
    std::cout << "array[1] = " << array[1] << "\n";
    std::cout << "array[5] = " << array[5] << "\n";

    // Const об'єкт — викликається const версія operator[]
    const IntArray constArray;
    // constArray[0] = 10;  // ❌ ПОМИЛКА: не можна змінювати const об'єкт
    std::cout << "constArray[0] = " << constArray[0] << "\n";  // ✅ Читання дозволено

    return 0;
}

Рядки 22–26: не-const operator[] повертає int& — посилання на елемент. Це дозволяє писати array[0] = 10 (використання як l-value).

Рядки 29–33: const operator[] повертає const int& — константне посилання. Це дозволяє читати елемент, але не змінювати його.

Рядок 24, 31: assert() перевіряє коректність індексу під час виконання. У Debug-режимі це викличе зупинку програми при виході за межі. У Release-режимі (з -DNDEBUG) assert вимикається.

Рядок 41–43: вирази array[i] = value компілятор перетворює на array.operator[](i) = value. Оскільки operator[] повертає посилання, присвоювання працює.

Рядок 53: для constArray викликається const версія operator[], яка повертає const int&. Спроба запису (рядок 52, закоментований) викликає помилку компіляції.

Чому індексатор повинен повертати посилання, а не копію значення?

Головне питання розробки оператора індексації: «Чому метод зобов'язаний повертати int&, а не звичайний int?».

У мові C++ оператор індексації використовується у двох принципово різних контекстах:

• Читання значення (r-value контекст): int x = array[0];
• Запис значення (l-value контекст): array[0] = 10;

Щоб елемент міг стояти ліворуч від оператора присвоювання (=), вираз array[0] повинен бути l-value (позначати реальну комірку пам'яті з фіксованою адресою, доступну для модифікації).

Сценарій 1: Повернення за значенням для примітивних типів

Якби неконстантна версія повертала значення за копією:

// ❌ Помилкова спроба повернення за значенням:
int operator[](int index)
{
    return data[index]; // Повертає тимчасову копію числа
}

У цьому випадку вираз array[0] = 10; компілятор розгорне у:

array.operator[](0) = 10; // ❌ Помилка компіляції!

Компілятор видасть помилку: error: lvalue required as left operand of assignment. Тимчасова копія числа, створена на стеку під час повернення з функції, є значенням категорії r-value (тимчасовим значенням). Записати нові дані в тимчасову копію неможливо — вона не має постійного місця в пам'яті та знищується одразу після обчислення виразу.

Сценарій 2: Катастрофа «тихої втрати даних» для класів та структур

Ще небезпечніша ситуація виникає, коли контейнер зберігає структури або об'єкти класів. Уявімо масив облікових записів студентів:

struct Student
{
    std::string name;
    int grade;
};

class StudentGroup
{
private:
    Student students[30];

public:
    // ❌ Повернення за копією (прихована пастка):
    Student operator[](int index)
    {
        return students[index];
    }
};

Тепер клієнтський код намагається оновити оцінку студента:

StudentGroup group;
group[0].grade = 100; // ⚠️ КОД КОМПІЛЮЄТЬСЯ, АЛЕ ДАНІ НЕ ЗБЕРІГАЮТЬСЯ!

Що відбувається під капотом:

1. Виклик group.operator[](0) створює новий тимчасовий об'єкт Student на стеку як копію students[0].
2. Оператор присвоювання змінює поле grade у тимчасовій копії.
3. У кінці рядка (на крапці з комою ;) тимчасова копія негайно знищується деструктором.
4. Оригінальний елемент students[0] всередині об'єкта group залишається недоторканим!

Це класичний приклад прихованої логічної помилки (silent data loss), яку надзвичайно складно виявити під час тестування: компілятор не видає жодних попереджень, але програма працює некоректно.

Рішення: повернення посилання на комірку пам'яті

Повертаючи Type&, оператор індексації повертає псевдонім (аліас) безпосередньо тієї комірки пам'яті, де зберігається елемент масиву:

int& operator[](int index)
{
    return data[index]; // Пряме посилання на елемент внутрішнього масиву
}

Вираз array[0] = 10; напряму записує число 10 за адресою &data[0], модифікуючи елемент на місці (in-place) без створення проміжних копій.

@startuml
skinparam style plain
skinparam backgroundColor #FFFFFF
skinparam packageStyle rectangle

package "Об'єкт IntArray (Пам'ять)" #F1F5F9 {
    rectangle "data[0] = 42 (адреса: 0x1000)" as Cell0 #DCFCE7
    rectangle "data[1] = 85 (адреса: 0x1004)" as Cell1 #F8FAFC
}

package "Повернення за посиланням: int& operator[](0)" #DBEAFE {
    rectangle "Посилання (l-value) → вказує прямо на 0x1000" as Ref #DCFCE7
    rectangle "array[0] = 99;\nЗапис безпосередньо за адресою 0x1000" as WriteRef
    Ref -> Cell0 : прямий доступ
    WriteRef -> Ref : модифікація
}

package "Повернення за копією: int operator[](0)" #FEE2E2 {
    rectangle "Тимчасова копія на стеку: 42 (адреса: 0x7FFF)" as Copy #FEE2E2
    rectangle "array[0] = 99;\nЗапис у 0x7FFF (копію)" as WriteCopy
    rectangle "Тимчасова копія 0x7FFF знищується!\nОригінал 0x1000 залишився рівним 42." as Destroy #FECACA
    WriteCopy -> Copy
    Copy -> Destroy
}
@enduml

Анатомія const-коректності: чому необхідні дві версії?

Для повноцінного контейнера в C++ завжди потрібна пара операторів:

int& operator[](int index);             // Версія 1: неконстантна
const int& operator[](int index) const; // Версія 2: константна

Проаналізуємо наслідки відсутності однієї з них:

1. Якщо прибрати константну версію: У реальних програмах об'єкти контейнерів часто передаються у функції за константним посиланням для уникнення копіювання:

   void printArray(const IntArray& arr)
   {
       for (int i = 0; i < arr.getSize(); ++i)
       {
           std::cout << arr[i] << " "; // ❌ ПОМИЛКА КОМПІЛЯЦІЇ!
       }
   }
   

   
   Компілятор видасть помилку: неконстантний метод operator[] не можна викликати для константного об'єкта arr. Ми не зможемо навіть прочитати дані з об'єкта, переданого як const!
2. Якщо прибрати неконстантну версію: Якщо залишити тільки const int& operator[](int index) const, масив стане виключно «тільки для читання» (read-only). Спроба записати нове значення arr[0] = 5; не скомпілюється навіть для неконстантного об'єкта arr, оскільки результат оператора — константне посилання.

Компілятор обирає потрібну версію автоматично на основі константності об'єкта, до якого застосовується оператор (точніше, типу покажчика this).

Безпека доступу: operator[] проти методу at()

У стандартній бібліотеці C++ (для std::vector, std::array, std::string) прийнято принципове архітектурне рішення:

• operator[] не виконує перевірку виходу за межі діапазону у релізному коді. Це реалізація принципу нульових накладних витрат (zero-overhead principle): операція індексації транслюється в одну машинну інструкцію зміщення адреси *(data + index). У математичних алгоритмах та циклах із мільйонами звернень додаткова перевірка if (index >= size) сповільнювала б роботу програми. Звернення за некоректним індексом через [] призводить до невизначеної поведінки (undefined behavior) або аварійного завершення (segmentation fault).
• Метод .at(index) гарантовано перевіряє межі. Якщо переданий індекс виходить за допустимий діапазон [0, size - 1], метод генерує виняток std::out_of_range. Це безпечний варіант для обробки користувацького вводу або ненадійних зовнішніх даних.

В навчальному класі IntArray ми використовували макрос assert():

assert(index >= 0 && index < size && "Index out of bounds");

Він працює виключно під час налагодження (у Debug-збірках) і повністю видаляється компілятором у фінальній оптимізованій релізній збірці (за наявності макросу -DNDEBUG).

Індексація довільними типами та багатовимірні масиви

Оператор індексації не обмежений лише цілими числами. Параметром operator[] може бути будь-який тип даних:

// Приклад асоціативного словника:
class PhoneBook
{
public:
    std::string& operator[](const std::string& name);
};

Такий підхід лежить в основі роботи контейнерів std::map та std::unordered_map, де звернення book["Олексій"] знаходить або створює запис за ключем.

Багатовимірні масиви: обмеження мови до C++23

До стандарту C++23 оператор індексації мав суворе обмеження: він міг приймати рівно один параметр. Спроба написати matrix[row, col] призводила до того, що компілятор сприймав кому як оператор «кома» (comma operator), обчислював вираз row, ігнорував його й передавав лише col.

Щоб реалізувати доступ до двовимірних матриць, розробники використовували два підходи:

1. Каскадна індексація matrix[row][col]: перший виклик operator[](row) повертав проміжний покажчик на рядок або допоміжний об'єкт-проксі (proxy object), а другий оператор [col] здійснював індексацію стовпця (детально розглянуто нижче у практичному завданні).
2. Оператор виклику функції matrix(row, col): перевантажували круглі дужки, які підтримують довільну кількість аргументів.

Лише у стандарті C++23 було знято це обмеження й дозволено перевантажувати багатовимірний оператор індексації напряму:

// Доступно у C++23:
double& operator[](size_t row, size_t col);

Оператор виклику функції: () та функтори

Оператор виклику функції () дозволяє об'єкту поводитися як функція. Об'єкти з перевантаженим operator() називаються функторами (functors) або об'єктами-функціями (function objects).

Чому це корисно? Функтори можуть зберігати стан між викликами, на відміну від звичайних функцій. Це робить їх потужнішими за функції у певних сценаріях (наприклад, у алгоритмах STL).

#include <iostream>

// Функтор-акумулятор: зберігає суму між викликами
class Accumulator
{
private:
    int total;

public:
    Accumulator() : total(0) {}

    // Оператор виклику: додає значення до суми
    int operator()(int value)
    {
        total += value;
        return total;
    }

    void reset()
    {
        total = 0;
    }
};

// Функтор-множник: зберігає коефіцієнт
class Multiplier
{
private:
    int factor;

public:
    Multiplier(int f) : factor(f) {}

    // Оператор виклику: множить аргумент на коефіцієнт
    int operator()(int value) const
    {
        return value * factor;
    }
};

int main()
{
    // Акумулятор: зберігає суму
    Accumulator sum;

    std::cout << "Accumulating:\n";
    std::cout << "sum(10) = " << sum(10) << "\n";  // 10
    std::cout << "sum(20) = " << sum(20) << "\n";  // 30
    std::cout << "sum(5) = " << sum(5) << "\n";    // 35

    sum.reset();
    std::cout << "After reset, sum(15) = " << sum(15) << "\n";  // 15

    // Множник: створюємо кілька функторів із різними коефіцієнтами
    Multiplier timesTwo(2);
    Multiplier timesTen(10);

    std::cout << "\nMultiplying:\n";
    std::cout << "timesTwo(5) = " << timesTwo(5) << "\n";    // 10
    std::cout << "timesTwo(8) = " << timesTwo(8) << "\n";    // 16
    std::cout << "timesTen(3) = " << timesTen(3) << "\n";    // 30

    return 0;
}

Рядки 13–17: operator() приймає один параметр int value, додає його до total, повертає суму. Вираз sum(10) компілятор перетворює на sum.operator()(10).

Рядки 48–50: кожен виклик sum(...) збільшує внутрішній стан total. Це демонструє збереження стану — ключову перевагу функторів над звичайними функціями.

Рядки 57–58: створюємо два різні функтори Multiplier із різними коефіцієнтами. Кожен має власний стан (factor). Це як створити кілька «параметризованих функцій».

Рядки 61–63: виклики timesTwo(5) та timesTen(3) демонструють, що функтори можуть мати різну поведінку залежно від їхнього стану.

Функтори-предикати: фільтрація даних

Предикат (predicate) — це функція або функтор, що повертає bool. Предикати використовуються для фільтрації елементів у контейнерах. Розглянемо функтор-предикат для перевірки діапазону значень:

#include <iostream>
#include <vector>
#include <algorithm>

// Функтор-предикат: перевіряє, чи входить число у діапазон
class InRange
{
private:
    int minValue;
    int maxValue;

public:
    InRange(int min, int max) : minValue(min), maxValue(max) {}

    // Оператор виклику: повертає true, якщо value у діапазоні [min, max]
    bool operator()(int value) const
    {
        return value >= minValue && value <= maxValue;
    }
};

int main()
{
    std::vector<int> numbers = {5, 12, 3, 18, 7, 25, 9, 14, 2, 20};

    std::cout << "Original numbers: ";
    for (int n : numbers)
    {
        std::cout << n << " ";
    }
    std::cout << "\n\n";

    // Створюємо функтор-предикат: діапазон [10, 20]
    InRange inRange(10, 20);

    // Знаходимо перший елемент у діапазоні
    auto it = std::find_if(numbers.begin(), numbers.end(), inRange);
    if (it != numbers.end())
    {
        std::cout << "First number in range [10, 20]: " << *it << "\n";
    }

    // Підраховуємо кількість чисел у діапазоні
    int count = std::count_if(numbers.begin(), numbers.end(), inRange);
    std::cout << "Count of numbers in range [10, 20]: " << count << "\n\n";

    // Виводимо всі числа у діапазоні
    std::cout << "Numbers in range [10, 20]: ";
    for (int n : numbers)
    {
        if (inRange(n))  // Використовуємо функтор як функцію
        {
            std::cout << n << " ";
        }
    }
    std::cout << "\n";

    return 0;
}

Рядки 15–19: operator() приймає int value і повертає bool. Це робить InRange предикатом — об'єктом, що перевіряє умову.

Рядок 37: std::find_if приймає функтор як третій параметр. Алгоритм викликає inRange(element) для кожного елемента, доки не знайде перший, що задовольняє умову.

Рядок 45: std::count_if підраховує кількість елементів, для яких inRange(element) повертає true.

Рядок 52: можемо викликати функтор безпосередньо: inRange(n) еквівалентний inRange.operator()(n).

Функтори-компаратори: власні правила сортування

Компаратор — це функтор, що визначає порядок сортування. Стандартне сортування std::sort за замовчуванням сортує за зростанням (<), але компаратор дозволяє задати власну логіку:

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

struct Student
{
    std::string name;
    int grade;
};

// Функтор-компаратор: сортує студентів за оцінкою (за спаданням)
class CompareByGrade
{
public:
    bool operator()(const Student& a, const Student& b) const
    {
        return a.grade > b.grade;  // Більша оцінка — вище у списку
    }
};

// Функтор-компаратор: сортує за іменем (за зростанням)
class CompareByName
{
public:
    bool operator()(const Student& a, const Student& b) const
    {
        return a.name < b.name;  // Лексикографічний порядок
    }
};

int main()
{
    std::vector<Student> students = {
        {"Alice", 85},
        {"Bob", 92},
        {"Charlie", 78},
        {"Diana", 95},
        {"Eve", 88}
    };

    // Сортування за оцінкою (за спаданням)
    std::sort(students.begin(), students.end(), CompareByGrade());

    std::cout << "Sorted by grade (descending):\n";
    for (const auto& s : students)
    {
        std::cout << s.name << ": " << s.grade << "\n";
    }

    // Сортування за іменем (за зростанням)
    std::sort(students.begin(), students.end(), CompareByName());

    std::cout << "\nSorted by name (ascending):\n";
    for (const auto& s : students)
    {
        std::cout << s.name << ": " << s.grade << "\n";
    }

    return 0;
}

Рядки 16–19: CompareByGrade::operator() приймає два об'єкти Student і повертає true, якщо перший має бути раніше за другий у відсортованій послідовності. Логіка a.grade > b.grade означає сортування за спаданням.

Рядок 43: std::sort приймає компаратор як третій параметр. Створюємо анонімний тимчасовий об'єкт CompareByGrade().

Рядок 52: змінюємо критерій сортування, передаючи інший функтор CompareByName(). Той самий вектор, різний порядок.

Функтори з декількома параметрами та станом

Функтори можуть приймати кілька параметрів і зберігати складний стан. Розглянемо функтор для обчислення зваженого середнього:

#include <iostream>
#include <vector>

// Функтор: обчислює зважене середнє
class WeightedAverage
{
private:
    double sumWeighted;  // Сума зважених значень
    double sumWeights;   // Сума ваг

public:
    WeightedAverage() : sumWeighted(0.0), sumWeights(0.0) {}

    // Оператор виклику з двома параметрами: значення і вага
    void operator()(double value, double weight)
    {
        sumWeighted += value * weight;
        sumWeights += weight;
    }

    double getAverage() const
    {
        return (sumWeights != 0.0) ? (sumWeighted / sumWeights) : 0.0;
    }

    void reset()
    {
        sumWeighted = 0.0;
        sumWeights = 0.0;
    }
};

int main()
{
    WeightedAverage avg;

    std::cout << "Calculating weighted average of grades:\n";
    std::cout << "Math (weight 3): 90\n";
    std::cout << "Physics (weight 3): 85\n";
    std::cout << "History (weight 2): 78\n";
    std::cout << "Art (weight 1): 95\n\n";

    // Додаємо оцінки з вагами
    avg(90, 3);  // Математика: оцінка 90, вага 3
    avg(85, 3);  // Фізика: оцінка 85, вага 3
    avg(78, 2);  // Історія: оцінка 78, вага 2
    avg(95, 1);  // Мистецтво: оцінка 95, вага 1

    std::cout << "Weighted average: " << avg.getAverage() << "\n\n";

    // Скидаємо стан і обчислюємо для іншого студента
    avg.reset();
    std::cout << "Another student:\n";
    avg(75, 3);
    avg(80, 3);
    avg(92, 2);
    avg(88, 1);
    std::cout << "Weighted average: " << avg.getAverage() << "\n";

    return 0;
}

Рядки 15–19: operator() приймає два параметри: value і weight. Це демонструє, що функтори можуть мати довільну кількість параметрів.

Рядки 45–48: кожен виклик avg(value, weight) накопичує дані у полях sumWeighted і sumWeights. Стан зберігається між викликами.

Рядок 50: метод getAverage() обчислює фінальний результат на основі накопиченого стану.

Зв'язок із лямбда-виразами (C++11)

У C++11 з'явилися лямбда-вирази (lambda expressions) — синтаксичний цукор для створення анонімних функторів. Кожна лямбда під капотом компілюється в клас із перевантаженим operator().

Порівняння функтора та лямбди:

class GreaterThan
{
private:
    int threshold;

public:
    GreaterThan(int t) : threshold(t) {}

    bool operator()(int value) const
    {
        return value > threshold;
    }
};

// Використання
std::vector<int> numbers = {5, 12, 3, 18, 7};
int count = std::count_if(numbers.begin(), numbers.end(), GreaterThan(10));

// Немає потреби у класі — лямбда генерує його автоматично
std::vector<int> numbers = {5, 12, 3, 18, 7};

// Захоплення змінної threshold за значенням
int threshold = 10;
int count = std::count_if(numbers.begin(), numbers.end(), 
                          [threshold](int value) { return value > threshold; });

// Або без захоплення (константа вбудована в лямбду)
int count2 = std::count_if(numbers.begin(), numbers.end(), 
                           [](int value) { return value > 10; });

Що відбувається під капотом лямбди:

// Лямбда:
[threshold](int value) { return value > threshold; }

// Компілюється приблизно у:
class __Lambda_Anonymous_1
{
private:
    int threshold;  // Захоплена змінна

public:
    __Lambda_Anonymous_1(int t) : threshold(t) {}

    bool operator()(int value) const
    {
        return value > threshold;
    }
};

std::vector<int> vec = {5, 2, 8, 1, 9};
std::sort(vec.begin(), vec.end(), std::greater<int>());  // Сортування за спаданням

Чому функтори в STL значно швидші за звичайні покажчики на функції?

Одне з найважливіших питань оптимізації продуктивності в C++: «Чому алгоритми STL, параметризовані функторами або лямбдами, працюють швидше за аналогічні функції мови C (наприклад, qsort), що приймають звичайні покажчики на функції?».

Відповідь полягає у механізмах роботи оптимізатора компілятора та системі шаблонів:

1. Виклик через покажчик на функцію (C-style): Коли функція приймає адресу функції bool (*cmp)(const Student&, const Student&), компілятор не знає точного тіла цієї функції під час трансляції алгоритму сортування. На машинному рівні кожен крок порівняння перетворюється на непрямий виклик (indirect call, інструкція call rax). Це створює відчутні накладні витрати:
   • Процесор змушений завантажувати адресу зі змінної та скидати конвеєр інструкцій у разі помилки передбачення переходу (branch misprediction).
   • Для кожного виклику створюється стековий кадр та зберігаються регістри процесора.
   • Компілятор не здатний заінлайнити (inline) тіло порівняння всередину циклу.
2. Виклик через функтор у шаблонах C++: У STL алгоритм std::sort визначено як шаблон:

   template <typename RandomIt, typename Compare>
   void sort(RandomIt first, RandomIt last, Compare comp);
   

   
   Зверніть увагу: компаратор Compare є типом, а не адресою функції! Коли ми передаємо об'єкт CompareByGrade(), компілятор створює спеціалізовану версію функції сортування саме для цього типу. Він бачить точний вихідний код методу CompareByGrade::operator() і виконує вбудовування коду (inline expansion).
   Операція виклику функції повністю зникає з бінарного коду: логіка a.grade > b.grade підставляється безпосередньо у внутрішній цикл алгоритму як проста інструкція порівняння процесора cmp. Завдяки цьому std::sort у C++ зазвичай працює у 2–5 разів швидше за стандартний qsort із бібліотеки C.

@startuml
skinparam style plain
skinparam backgroundColor #FFFFFF

package "Покажчик на функцію (qsort)" #FEE2E2 {
    rectangle "Алгоритм сортування" as AlgoC #FFFFFF
    rectangle "Непрямий виклик: call [rax]\n(збереження регістрів, створення стека)" as CallC #FECACA
    rectangle "Функція-компаратор у пам'яті" as FuncC #FFFFFF
    AlgoC -> CallC : на кожній ітерації
    CallC -> FuncC
}

package "Функтор у шаблоні C++ (std::sort)" #DCFCE7 {
    rectangle "Алгоритм сортування\nзі спеціалізацією типу" as AlgoCPP #FFFFFF
    rectangle "Вбудована машинна інструкція:\ncmp [rdi], [rsi]\n(нульові витрати на виклик)" as InlineCPP #BBF7D0
    AlgoCPP *-- InlineCPP : Inlining компілятора
}
@enduml

Багатовимірна індексація за допомогою operator()

Оператор виклику функції () володіє унікальною властивістю, якої немає в жодного іншого оператора C++:

• Він може приймати будь-яку кількість аргументів (від нуля до кількох).
• Він підтримує значення аргументів за замовчуванням.

Саме тому в інженерній практиці C++ оператор () традиційно використовується як стандартний спосіб доступу до елементів двовимірних і тривимірних матриць, таблиць та тензорів:

#include <iostream>
#include <cassert>

class SimpleMatrix
{
private:
    int rows;
    int cols;
    double* data;

public:
    SimpleMatrix(int r, int c) : rows(r), cols(c), data(new double[r * c]()) {}

    ~SimpleMatrix()
    {
        delete[] data;
    }

    // Двовимірний оператор доступу: читання та запис
    double& operator()(int r, int c)
    {
        assert(r >= 0 && r < rows && c >= 0 && c < cols && "Matrix index out of bounds");
        return data[r * cols + c];
    }

    // Константна версія для читання
    const double& operator()(int r, int c) const
    {
        assert(r >= 0 && r < rows && c >= 0 && c < cols && "Matrix index out of bounds");
        return data[r * cols + c];
    }
};

int main()
{
    SimpleMatrix mat(3, 3);

    // Зручний синтаксис звернення з двома координатами:
    mat(0, 0) = 1.0;
    mat(1, 1) = 5.5;
    mat(2, 2) = 9.9;

    std::cout << "mat(1, 1) = " << mat(1, 1) << "\n";

    return 0;
}

Переваги такого підходу:

1. Єдиний виклик методу: координати (r, c) передаються одночасно, тому метод може перевірити межі обох осей одразу.
2. Чистота інкапсуляції: клас повністю контролює обчислення зміщення в одновимірному буфері пам'яті (r * cols + c), не виставляючи назовні проміжних покажчиків.

Оператори присвоювання: =, +=, -=, *=, /=

Оператори присвоювання модифікують лівий операнд і повертають посилання на нього для підтримки ланцюгових присвоювань (a = b = c). Ці оператори завжди реалізуються як методи класу.

Базовий оператор присвоювання =

Оператор присвоювання = викликається при a = b, коли a вже існує (на відміну від конструктора копіювання, що викликається при ініціалізації Counter a = b).

#include <iostream>

class Counter
{
private:
    int value;

public:
    Counter(int v = 0) : value(v) {}

    int getValue() const { return value; }

    // Оператор присвоювання
    Counter& operator=(const Counter& other)
    {
        // Перевірка самоприсвоювання (self-assignment check)
        if (this == &other)
        {
            return *this;
        }

        // Копіюємо дані
        value = other.value;

        // Повертаємо посилання на себе для ланцюгових присвоювань
        return *this;
    }

    void print() const
    {
        std::cout << "Counter: " << value;
    }
};

int main()
{
    Counter a(10);
    Counter b(20);
    Counter c(30);

    std::cout << "Initial values:\n";
    std::cout << "a = "; a.print(); std::cout << "\n";
    std::cout << "b = "; b.print(); std::cout << "\n";
    std::cout << "c = "; c.print(); std::cout << "\n\n";

    // Просте присвоювання
    a = b;
    std::cout << "After a = b:\n";
    std::cout << "a = "; a.print(); std::cout << "\n\n";

    // Ланцюгове присвоювання: a = b = c виконується справа наліво
    a = b = c;
    std::cout << "After a = b = c:\n";
    std::cout << "a = "; a.print(); std::cout << "\n";
    std::cout << "b = "; b.print(); std::cout << "\n";

    // Самоприсвоювання — має бути безпечним
    a = a;
    std::cout << "\nAfter a = a (self-assignment):\n";
    std::cout << "a = "; a.print(); std::cout << "\n";

    return 0;
}

Рядки 14–27: operator= повертає Counter& — посилання на поточний об'єкт. Це дозволяє ланцюгові присвоювання.

Рядки 17–20: перевірка самоприсвоювання if (this == &other). Якщо a = a, одразу повертаємо *this. Це оптимізація та захист від помилок (важливо для класів із динамічною пам'яттю).

Рядок 26: return *this; — повертаємо посилання на поточний об'єкт. Компілятор перетворює a = b на a.operator=(b), що повертає a.

Рядок 53: ланцюгове присвоювання a = b = c виконується справа наліво: спочатку b = c (повертає b), потім a = b. Завдяки поверненню *this це працює.

Рядок 59: самоприсвоювання a = a — рідкісний сценарій, але перевірка гарантує коректність.

Чому operator= зобов'язаний повертати посилання Counter&?

Сигнатура оператора присвоювання завжди має вигляд ClassName& operator=(const ClassName& other). Студенти часто цікавляться: «Чи не можна повернути void або повертати об'єкт за значенням Counter?».

Проаналізуємо наслідки відхилення від стандарту:

1. Якщо метод повертає void: У вбудованих типах мови C++ оператор присвоювання підтримує ланцюжки:

   a = b = c;
   

   
   Операція присвоювання має правобічну асоціативність (виконується справа наліво): вираз (b = c) обчислюється першим, змінює b і повертає результат, який потім передається як правий операнд для a = .... Якби метод повертав void, вираз розгорнувся б у a.operator=(b.operator=(c)), що призведе до помилки компіляції: неможливо передати тип void у метод, який очікує const Counter&.
2. Якщо метод повертає значення за копією (Counter): При поверненні за копією вираз (a = b) створить тимчасовий анонімний об'єкт. Якщо хтось напише складніший вираз на зразок:

   (a = b) = c;
   

   
   При поверненні за значенням значення c буде присвоєно тимчасовій копії, а оригінальний об'єкт a залишиться зі значенням b. Для вбудованих типів C++ вираз (x = y) = z змінює саму змінну x на z, тому що результат присвоювання є l-value посиланням.

Повернення *this за посиланням (Counter&) повністю зберігає узгодженість поведінки класу зі стандартними типами мови C++ та уникає будь-якого зайвого копіювання пам'яті.

Катастрофа самоприсвоювання: детальний розбір

Розглянемо клас DynamicArray, що керує динамічною пам'яттю без перевірки самоприсвоювання:

#include <iostream>
#include <cstring>

class DynamicArray
{
private:
    int* data;
    int size;

public:
    DynamicArray(int sz) : size(sz)
    {
        data = new int[sz];
        for (int i = 0; i < sz; ++i)
        {
            data[i] = i * 10;
        }
        std::cout << "Allocated array at " << data << "\n";
    }

    ~DynamicArray()
    {
        std::cout << "Deleting array at " << data << "\n";
        delete[] data;
    }

    // ❌ НЕБЕЗПЕЧНИЙ operator= без перевірки самоприсвоювання
    DynamicArray& operator=(const DynamicArray& other)
    {
        // Крок 1: Звільняємо стару пам'ять
        delete[] data;
        std::cout << "Deleted old memory at " << data << "\n";

        // Крок 2: Виділяємо нову пам'ять
        size = other.size;
        data = new int[size];
        std::cout << "Allocated new memory at " << data << "\n";

        // Крок 3: Копіюємо дані з other
        for (int i = 0; i < size; ++i)
        {
            data[i] = other.data[i];  // ← КАТАСТРОФА при самоприсвоюванні!
        }

        return *this;
    }

    void print() const
    {
        std::cout << "[";
        for (int i = 0; i < size; ++i)
        {
            std::cout << data[i];
            if (i < size - 1) std::cout << ", ";
        }
        std::cout << "]";
    }
};

int main()
{
    DynamicArray arr(5);

    std::cout << "\n=== BEFORE self-assignment ===\n";
    std::cout << "arr = ";
    arr.print();
    std::cout << "\n";

    // КАТАСТРОФА: самоприсвоювання
    std::cout << "\n=== EXECUTING arr = arr ===\n";
    arr = arr;  // ← this == &other, але немає перевірки!

    std::cout << "\n=== AFTER self-assignment ===\n";
    std::cout << "arr = ";
    arr.print();  // ← Undefined Behavior: читання зі звільненої пам'яті
    std::cout << "\n";

    return 0;
}

Allocated array at 0x600001234560

=== BEFORE self-assignment ===
arr = [0, 10, 20, 30, 40]

=== EXECUTING arr = arr ===
Deleted old memory at 0x600001234560
Allocated new memory at 0x600001788900
arr = [0, 0, 0, 0, 0]  ← Дані загублено!

=== AFTER self-assignment ===
arr = [0, 0, 0, 0, 0]  ← Замість [0, 10, 20, 30, 40]

Deleting array at 0x600001788900

Анатомія катастрофи (покроковий аналіз)

Що відбувається при виконанні arr = arr:

Крок 1 (рядок 28): delete[] data;

• До: data вказує на блок пам'яті 0x600001234560 з даними [0, 10, 20, 30, 40]
• Після: пам'ять звільнено, data — висячий покажчик (dangling pointer)
• Проблема: other.data також вказує на цю звільнену пам'ять (бо this == &other)!

@startuml
!theme plain

skinparam rectangleBackgroundColor #FFE6E6
skinparam rectangleBorderColor #CC0000

rectangle "Купа (heap)" {
  rectangle "0x600001234560\n[0, 10, 20, 30, 40]\n❌ ЗВІЛЬНЕНО" as freed #FFE6E6
}

rectangle "Стек (stack)" {
  rectangle "arr\n(this)" as arr1 {
    rectangle "data → 0x600001234560" as ptr1 #FFE6E6
    rectangle "size = 5" as size1
  }
}

note right of freed
  delete[] data викликаний
  Пам'ять звільнено, але покажчик
  досі вказує на неї
end note

note right of ptr1
  Висячий покажчик!
  Вказує на звільнену пам'ять
end note

ptr1 -[#CC0000,dashed]-> freed : dangling pointer
@enduml

Крок 2 (рядки 32–34): Виділення нової пам'яті

• Виділяємо новий блок 0x600001788900
• Проблема: other.data досі вказує на звільнену пам'ять 0x600001234560!

Крок 3 (рядки 37–40): Копіювання з other.data

data[i] = other.data[i];  // ← Читаємо зі звільненої пам'яті!

• other.data[i] — доступ до звільненої пам'яті (undefined behavior)
• Може повернути:
  • Нулі (якщо ОС очистила пам'ять)
  • Сміттєві дані
  • Викликати segmentation fault (крах програми)

before_self_assignment:
  heap:
    - address: "0x600001234560"
      content: "[0, 10, 20, 30, 40]"
      status: "allocated"
      owner: "arr.data"
  stack:
    - name: "arr"
      data: "→ 0x600001234560"
      size: 5

after_delete_step:
  heap:
    - address: "0x600001234560"
      content: "❌ FREED MEMORY (undefined)"
      status: "freed"
      danger: "dangling pointer!"
    - address: "0x600001788900"
      content: "[?, ?, ?, ?, ?]"
      status: "allocated (new)"
  stack:
    - name: "arr"
      data: "→ 0x600001788900 (NEW)"
      size: 5
  problem: "other.data досі вказує на 0x600001234560 (freed)!"

after_copy_step:
  heap:
    - address: "0x600001788900"
      content: "[0, 0, 0, 0, 0] ← Скопійовано сміття!"
      status: "allocated"
  stack:
    - name: "arr"
      data: "→ 0x600001788900"
      size: 5
  result: "Дані загублено через копіювання зі звільненої пам'яті"

Безпечна реалізація з перевіркою

DynamicArray& operator=(const DynamicArray& other)
{
    // ✅ Перевірка самоприсвоювання
    if (this == &other)
    {
        std::cout << "Self-assignment detected, skipping copy\n";
        return *this;
    }

    // Тепер безпечно звільняти пам'ять
    delete[] data;

    size = other.size;
    data = new int[size];

    // Копіюємо з валідної пам'яті
    for (int i = 0; i < size; ++i)
    {
        data[i] = other.data[i];
    }

    return *this;
}

Allocated array at 0x600001234560

=== BEFORE self-assignment ===
arr = [0, 10, 20, 30, 40]

=== EXECUTING arr = arr ===
Self-assignment detected, skipping copy

=== AFTER self-assignment ===
arr = [0, 10, 20, 30, 40]  ← Дані збережено!

Deleting array at 0x600001234560

Чому це критично важливо?

Реальні сценарії самоприсвоювання:

1. Цикли з контейнерами:

   std::vector<DynamicArray> vec;
   // ... заповнення вектора
   vec[i] = vec[i];  // Випадково перезаписали самого себе
   

2. Складні вирази:

   DynamicArray& getArray(int index);
   getArray(5) = getArray(5);  // Неочевидне самоприсвоювання
   

3. Алгоритми сортування:

   std::sort(vec.begin(), vec.end());  // Може викликати arr = arr
   

Резюме: правило безпеки

Неявний оператор присвоювання від компілятора

Якщо ви не оголошуєте власний operator=, компілятор автоматично генерує неявний оператор присвоювання (implicitly-declared copy assignment operator). Ця згенерована версія виконує порогове копіювання (memberwise copy) — копіює кожне поле класу окремо.

Для простих класів (без покажчиків, файлових дескрипторів, ресурсів) неявний operator= працює коректно:

class Point
{
private:
    int x;
    int y;

public:
    Point(int xCoord, int yCoord) : x(xCoord), y(yCoord) {}
    
    // Компілятор автоматично генерує:
    // Point& operator=(const Point& other)
    // {
    //     x = other.x;
    //     y = other.y;
    //     return *this;
    // }
};

int main()
{
    Point p1(10, 20);
    Point p2(30, 40);
    
    p1 = p2;  // ✅ Викликається неявний operator=
    // Результат: p1.x = 30, p1.y = 40
}

Для класів із динамічною пам'яттю неявний operator= небезпечний — він копіює покажчик, а не дані:

class DynamicArray
{
private:
    int* data;
    int size;

public:
    DynamicArray(int sz) : size(sz)
    {
        data = new int[sz];
    }
    
    ~DynamicArray()
    {
        delete[] data;
    }
    
    // Компілятор генерує неявний operator= (НЕБЕЗПЕЧНИЙ!):
    // DynamicArray& operator=(const DynamicArray& other)
    // {
    //     data = other.data;  // ← Shallow copy: копіюється покажчик!
    //     size = other.size;
    //     return *this;
    // }
};

int main()
{
    DynamicArray arr1(5);
    DynamicArray arr2(3);
    
    arr1 = arr2;  // ❌ НЕБЕЗПЕЧНО: обидва об'єкти вказують на одну пам'ять
    
    // Під час виходу зі scope:
    // 1. ~arr2() викликається → delete[] data (адреса X)
    // 2. ~arr1() викликається → delete[] data (адреса X знову!) → ПОДВІЙНЕ ВИДАЛЕННЯ!
}

class NonCopyable
{
public:
    NonCopyable& operator=(const NonCopyable&) = delete;  // Заборона копіювання
};

Різниця між operator= і конструктором копіювання

Оператор присвоювання і конструктор копіювання виглядають схоже, але викликаються у різних сценаріях:

Приклад різниці:

#include <iostream>

class Resource
{
private:
    int* data;
    int value;

public:
    // Конструктор
    Resource(int val) : value(val)
    {
        data = new int(val);
        std::cout << "Constructor: allocated " << value << "\n";
    }

    // Конструктор копіювання
    Resource(const Resource& other) : value(other.value)
    {
        data = new int(*other.data);
        std::cout << "Copy Constructor: copied " << value << "\n";
    }

    // Оператор присвоювання
    Resource& operator=(const Resource& other)
    {
        std::cout << "Assignment Operator: assigning " << other.value << "\n";
        
        if (this == &other)
            return *this;

        delete data;  // ← Звільняємо СТАРІ дані (конструктор копіювання цього не робить!)
        
        value = other.value;
        data = new int(*other.data);
        
        return *this;
    }

    ~Resource()
    {
        std::cout << "Destructor: deleting " << value << "\n";
        delete data;
    }
};

int main()
{
    std::cout << "=== Scenario 1: Copy Constructor ===\n";
    Resource r1(10);
    Resource r2 = r1;  // ← Ініціалізація: викликається конструктор копіювання
    
    std::cout << "\n=== Scenario 2: Assignment Operator ===\n";
    Resource r3(20);
    Resource r4(30);
    r3 = r4;  // ← r3 вже існує: викликається operator=
    
    std::cout << "\n=== Scenario 3: Initialization vs Assignment ===\n";
    Resource r5(40);
    Resource r6 = r5;  // ← Конструктор копіювання (ініціалізація)
    r6 = r5;           // ← Оператор присвоювання (присвоювання)
    
    return 0;
}

Ключові відмінності:

1. Ініціалізація (Resource r2 = r1;) — це НЕ присвоювання! Це синтаксичний цукор для конструктора копіювання.
2. Оператор присвоювання повинен звільнити старі ресурси (рядок 32: delete data), бо об'єкт вже має валідний стан.
3. Конструктор копіювання не звільняє нічого — об'єкт щойно створюється, у нього ще немає ресурсів.

Патерн копіювання з обміном (Copy-and-Swap)

У попередніх розділах ми бачили, що класичний оператор присвоювання вимагає ручної перевірки if (this == &other), ручного виклику delete[] та копіювання кожного поля. Проте цей класичний підхід має серйозну інженерну проблему: відсутність безпеки винятків (Exception Safety).

Проблема безпеки винятків у класичному operator=

Погляньмо, що станеться в класичній реалізації:

DynamicArray& operator=(const DynamicArray& other)
{
    if (this == &other) return *this;

    delete[] data; // 1. Стару пам'ять звільнено!

    size = other.size;
    data = new int[size]; // 2. ⚠️ А якщо тут виникне виняток std::bad_alloc?

    for (int i = 0; i < size; ++i) data[i] = other.data[i];
    return *this;
}

Якщо операційна система не зможе виділити пам'ять під новий масив, оператор new згенерує виняток std::bad_alloc. Оскільки стару пам'ять ми вже звільнили на кроці 1, покажчик data містить адресу вивільненої пам'яті, а об'єкт переходить у пошкоджений, невалідний стан. Коли програма перехопить виняток і спробує знищити цей об'єкт, деструктор спробує повторно викликати delete[] data, що призведе до аварійного завершення програми.

Рішення: патерн Copy-and-Swap

Для гарантування суворої безпеки винятків (Strong Exception Safety Guarantee) використовують патерн копіювання з обміном. Його суть полягає в тому, що всі операції виділення пам'яті виконуються до модифікації поточного об'єкта, а заміна ресурсів відбувається за допомогою неблокуючого обміну покажчиками:

#include <iostream>
#include <algorithm> // для std::swap

class SafeArray
{
private:
    int* data;
    int size;

public:
    SafeArray(int sz = 0) : size(sz), data(sz > 0 ? new int[sz]() : nullptr) {}

    // Конструктор копіювання (виділяє пам'ять і копіює дані)
    SafeArray(const SafeArray& other) : size(other.size), data(other.size > 0 ? new int[other.size] : nullptr)
    {
        for (int i = 0; i < size; ++i)
        {
            data[i] = other.data[i];
        }
    }

    ~SafeArray()
    {
        delete[] data;
    }

    // Оператор присвоювання за патерном Copy-and-Swap
    // Зверніть увагу: аргумент передається ЗА ЗНАЧЕННЯМ!
    SafeArray& operator=(SafeArray other) noexcept
    {
        // Обмінюємо ресурси між *this та копією other
        std::swap(data, other.data);
        std::swap(size, other.size);

        // Повертаємо посилання на себе
        return *this;
        // Локальний об'єкт other знищується тут, звільняючи СТАРУ пам'ять поточного об'єкта
    }
};

Чому цей підхід є надійним стандартом?

1. Строга гарантія безпеки винятків: Параметр SafeArray other передається за значенням. Це означає, що компілятор викликає конструктор копіювання ще до входу в тіло оператора. Якщо пам'яті недостатньо і виникає std::bad_alloc, виняток вилітає до того, як об'єкт *this зазнає бодай якихось змін. Стан вихідного об'єкта залишається неушкодженим.
2. Операція обміну не генерує винятків: Функція std::swap для покажчиків та цілих чисел гарантовано не викидає винятків (noexcept) — вона лише змінює місцями адреси в регістрах процесора.
3. Автоматичне звільнення старої пам'яті: Після виконання std::swap об'єкт other володіє старим буфером пам'яті, який раніше належав *this. Коли метод завершує роботу, локальний об'єкт other виходить з області видимості, і його деструктор самостійно та чисто видаляє старі дані.
4. Автоматична безпека самоприсвоювання: У разі виразу a = a створюється тимчасова копія a, ресурси міняються місцями, а копія знищується. Дані не втрачаються, і програма не зазнає збоїв навіть без явної перевірки if (this == &other).

@startuml
skinparam style plain
skinparam backgroundColor #FFFFFF
skinparam sequenceMessageAlign center

participant "Клієнт" as Client #DBEAFE
participant "a (*this)" as A #DCFCE7
participant "other (копія на стеку)" as Other #FEF3C7
participant "Купа (Heap)" as Heap #F1F5F9

Client -> Other : Конструктор копіювання SafeArray(b)
Other -> Heap : new int[size] (виділення нового буфера B)
Client -> A : a.operator=(other)
A -> Other : std::swap(data, other.data)
note over A, Other #E2E8F0
  Покажчики просто обмінялися значеннями:
  a тепер вказує на буфер B,
  other тепер вказує на старий буфер A!
end note
A --> Client : return *this
Other -> Heap : ~SafeArray() -> delete[] старий буфер A
note over Other, Heap #FECACA
  Деструктор other автоматично звільняє
  старі ресурси, які раніше належали 'a'.
end note
@enduml

Складені оператори присвоювання: +=, -=, *=, /=

Складені оператори присвоювання модифікують об'єкт і повертають посилання на нього:

#include <iostream>

class Counter
{
private:
    int value;

public:
    Counter(int v = 0) : value(v) {}

    int getValue() const { return value; }

    // Оператор +=
    Counter& operator+=(int amount)
    {
        value += amount;
        return *this;
    }

    // Оператор -=
    Counter& operator-=(int amount)
    {
        value -= amount;
        return *this;
    }

    // Оператор *=
    Counter& operator*=(int multiplier)
    {
        value *= multiplier;
        return *this;
    }

    // Оператор /=
    Counter& operator/=(int divisor)
    {
        if (divisor != 0)
        {
            value /= divisor;
        }
        else
        {
            std::cerr << "Error: Division by zero\n";
        }
        return *this;
    }

    void print() const
    {
        std::cout << "Counter: " << value;
    }
};

int main()
{
    Counter count(10);

    std::cout << "Initial: ";
    count.print();
    std::cout << "\n";

    // Використання складених операторів
    count += 5;
    std::cout << "After += 5: ";
    count.print();
    std::cout << "\n";

    count -= 3;
    std::cout << "After -= 3: ";
    count.print();
    std::cout << "\n";

    count *= 2;
    std::cout << "After *= 2: ";
    count.print();
    std::cout << "\n";

    count /= 4;
    std::cout << "After /= 4: ";
    count.print();
    std::cout << "\n";

    // Ланцюгові операції
    count += 10;
    count *= 2;
    std::cout << "After += 10, *= 2: ";
    count.print();
    std::cout << "\n";

    return 0;
}

Рядки 14–18: operator+= додає значення до value і повертає *this. Вираз count += 5 еквівалентний count.operator+=(5).

Рядки 35–46: operator/= містить перевірку ділення на нуль. Якщо divisor == 0, виводить помилку і залишає значення незмінним.

Рядки 88–90: складені оператори можна викликати послідовно. Кожен модифікує об'єкт і повертає посилання, що дозволяє наступний виклик.

Чому += повертає посилання, а + — новий об'єкт?

Студенти часто плутають семантику звичайних бінарних операторів та складених операторів присвоювання. Їхня різниця полягає у призначенні операції:

• Складене присвоювання (a += b): це мутуюча операція на місці (in-place mutation). Лівий операнд змінює власний стан, тому повернення посилання на самого себе *this (Counter&) не потребує виділення нової пам'яті чи виклику конструкторів. Це забезпечує максимальну швидкодію та дозволяє будувати ланцюжкові операції: (a += b) += c;.
• Бінарне додавання (a + b): це чиста операція обчислення нового значення (pure calculation). Вона не має права змінювати ані операнд a, ані операнд b. Результатом є абсолютно нова сума двох величин, тому оператор + зобов'язаний повертати результат за значенням (Counter). Повернути посилання з + неможливо, оскільки новостворена сума є локальним тимчасовим об'єктом.

Counter operator+(Counter left, int right)
{
    left += right; // 1. Модифікуємо копію left
    return left;   // 2. Повертаємо модифіковану копію за значенням
}

Складені оператори з операндами того ж типу

Складені оператори можуть приймати не лише примітиви (int, double), але й об'єкти того ж класу. Розглянемо клас Vector2D — двовимірний вектор:

#include <iostream>
#include <cmath>

class Vector2D
{
private:
    double x;
    double y;

public:
    Vector2D(double xCoord = 0, double yCoord = 0) : x(xCoord), y(yCoord) {}

    double getX() const { return x; }
    double getY() const { return y; }

    // Оператор += з іншим вектором
    Vector2D& operator+=(const Vector2D& other)
    {
        x += other.x;
        y += other.y;
        return *this;
    }

    // Оператор -= з іншим вектором
    Vector2D& operator-=(const Vector2D& other)
    {
        x -= other.x;
        y -= other.y;
        return *this;
    }

    // Оператор *= зі скаляром
    Vector2D& operator*=(double scalar)
    {
        x *= scalar;
        y *= scalar;
        return *this;
    }

    // Оператор /= зі скаляром
    Vector2D& operator/=(double scalar)
    {
        if (scalar != 0)
        {
            x /= scalar;
            y /= scalar;
        }
        else
        {
            std::cerr << "Error: Division by zero\n";
        }
        return *this;
    }

    double length() const
    {
        return std::sqrt(x * x + y * y);
    }

    void print() const
    {
        std::cout << "(" << x << ", " << y << ")";
    }
};

int main()
{
    Vector2D v1(3.0, 4.0);
    Vector2D v2(1.0, 2.0);

    std::cout << "v1 = ";
    v1.print();
    std::cout << ", length = " << v1.length() << "\n";

    std::cout << "v2 = ";
    v2.print();
    std::cout << "\n\n";

    // Додавання векторів
    v1 += v2;
    std::cout << "After v1 += v2:\nv1 = ";
    v1.print();
    std::cout << "\n\n";

    // Віднімання векторів
    v1 -= Vector2D(1.0, 1.0);
    std::cout << "After v1 -= (1, 1):\nv1 = ";
    v1.print();
    std::cout << "\n\n";

    // Множення на скаляр
    v1 *= 2.0;
    std::cout << "After v1 *= 2.0:\nv1 = ";
    v1.print();
    std::cout << ", length = " << v1.length() << "\n\n";

    // Ділення на скаляр (нормалізація)
    v1 /= v1.length();
    std::cout << "After v1 /= length (normalization):\nv1 = ";
    v1.print();
    std::cout << ", length = " << v1.length() << "\n";

    return 0;
}