Вказівники на вказівники

Ще один рівень непрямості: навіщо вказівник на вказівник?

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

• Динамічні двовимірні масиви, розміри яких невідомі на момент компіляції.
• Масиви рядків у стилі C (класичний приклад — char** argv).
• Функції, що змінюють самий вказівник через параметр (передача вказівника «за посиланням» у стилі C).

Усе це стає можливим завдяки конструкції вказівник на вказівник (pointer to pointer), або подвійний вказівник (double pointer), що оголошується через подвоєну зірочку: int**.

Базова концепція: вказівник — це теж змінна

Щоб зрозуміти int**, достатньо пригадати одну фундаментальну властивість: вказівник — це звичайна змінна, яка зберігає адресу. Як і будь-яка змінна, вона сама займає місце в пам'яті і, відповідно, має власну адресу.

Візьмемо звичайний ланцюжок:

int value   = 7;       // int-змінна: зберігає 7, знаходиться за адресою 0x1000
int* ptr    = &value;  // int*-вказівник: зберігає 0x1000, сам за адресою 0x2000
int** pptr  = &ptr;    // int**-вказівник: зберігає 0x2000, сам за адресою 0x3000

graph LR
    PP["int** pptr<br/>адреса: 0x3000<br/>значення: 0x2000"]
    P["int* ptr<br/>адреса: 0x2000<br/>значення: 0x1000"]
    V["int value<br/>адреса: 0x1000<br/>значення: 7"]

    PP -->|"розіменування *pptr"| P
    P  -->|"розіменування *ptr"| V

    style PP fill:#f59e0b,color:#000
    style P  fill:#3b82f6,color:#fff
    style V  fill:#22c55e,color:#fff

Щоб дістатися до значення 7 через pptr, нам потрібно виконати два розіменування послідовно:

• *pptr → отримуємо ptr (тобто адресу 0x1000)
• **pptr → отримуємо value (тобто 7)

Це і є суть подвійного вказівника — кожна додаткова зірочка в оголошенні відповідає одному додатковому рівню розіменування при зверненні до кінцевого значення.

Оголошення, ініціалізація та розіменування

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

#include <iostream>

int main()
{
    int   value = 7;
    int*  ptr   = &value;  // вказує на value
    int** pptr  = &ptr;    // вказує на ptr

    std::cout << value   << '\n'; // 7  — пряме звернення до змінної
    std::cout << *ptr    << '\n'; // 7  — розіменування ptr
    std::cout << **pptr  << '\n'; // 7  — подвійне розіменування pptr

    // Можна також модифікувати value через pptr:
    **pptr = 42;
    std::cout << value << '\n';   // 42 — змінилось!

    return 0;
}

Розбір ключових моментів:

• Рядок 6. int** pptr = &ptr; — беремо адресу вказівника ptr. Оператор & повертає int** (вказівник на int*), що і є типом pptr.
• Рядок 11. **pptr — два розіменування: перше дає нам ptr (типу int*), друге — значення, на яке вказує ptr.
• Рядок 14. **pptr = 42 — через подвійне розіменування ми записуємо нове значення безпосередньо в value. Усі три вирази (value, *ptr, **pptr) тепер дадуть 42.

Масиви вказівників

Найпоширеніше практичне застосування int** — динамічне виділення масиву вказівників. Уявіть, що нам потрібен масив із 3 вказівників на int, кожен з яких спрямований на власну змінну:

#include <iostream>

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

    int** ptrs = new int*[3]; // масив із 3-х вказівників на int
    ptrs[0] = &a;             // ptrs[0] вказує на a
    ptrs[1] = &b;             // ptrs[1] вказує на b
    ptrs[2] = &c;             // ptrs[2] вказує на c

    for (int i = 0; i < 3; ++i)
    {
        std::cout << *ptrs[i] << '\n'; // розіменовуємо кожен вказівник
    }

    delete[] ptrs; // звільняємо лише масив вказівників, не самі змінні!
    return 0;
}

Зверніть увагу на рядок 16: delete[] ptrs звільняє лише сам масив вказівників (ptrs), але не об'єкти, на які вони вказують (a, b, c). Ті знаходяться на стеку і знищуються автоматично при виході з main. Плутанина в цьому питанні — одна з найпоширеніших причин витоків пам'яті або подвійного звільнення.

Динамічні двовимірні масиви

Найбільш складне, але і найбільш практично важливе застосування int** — динамічне виділення двовимірного масиву, розмір якого невідомий під час компіляції.

Чому new int[rows][cols] не працює для динамічних розмірів

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

int (*matrix)[7] = new int[15][7]; // ✅ Але тільки якщо 7 — константа компіляції

Однак якщо кількість стовпців задається під час виконання — наприклад, читається з вводу користувача — такий синтаксис є неможливим. Саме тут і потрібен int**.

Класичний підхід: масив рядків

Ідея проста: замість одного суцільного блоку пам'яті ми створюємо масив вказівників, кожен з яких вказує на окремо виділений «рядок»:

int rows = 4;
int cols = 5;

int** matrix = new int*[rows]; // масив із rows вказівників — це «рядки»

for (int r = 0; r < rows; ++r)
{
    matrix[r] = new int[cols]; // кожен рядок — окремий масив у купі
}

for (int r = 0; r < rows; ++r)
{
    for (int c = 0; c < cols; ++c)
    {
        matrix[r][c] = r * cols + c; // заповнюємо як у 2D-масиві
    }
}

std::cout << matrix[1][3] << '\n'; // Виводить: 8
// Синтаксис matrix[r][c] еквівалентний (*(matrix + r))[c]

for (int r = 0; r < rows; ++r)
{
    delete[] matrix[r]; // спочатку — кожен рядок
}
delete[] matrix; // потім — масив вказівників

Повний приклад роботи з динамічним двовимірним масивом:

#include <iostream>

int main()
{
    int rows = 3;
    int cols = 4;

    // Виділення
    int** matrix = new int*[rows];
    for (int r = 0; r < rows; ++r)
        matrix[r] = new int[cols];

    // Заповнення
    for (int r = 0; r < rows; ++r)
        for (int c = 0; c < cols; ++c)
            matrix[r][c] = r * 10 + c;

    // Вивід
    for (int r = 0; r < rows; ++r)
    {
        for (int c = 0; c < cols; ++c)
            std::cout << matrix[r][c] << '\t';
        std::cout << '\n';
    }

    // Звільнення (зворотний порядок!)
    for (int r = 0; r < rows; ++r)
        delete[] matrix[r];
    delete[] matrix;

    return 0;
}

Структура пам'яті: чому рядки не є суміжними

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

graph TD
    M["matrix (стек)<br/>int** → 0xA000"]
    R0["matrix[0] (купа)<br/>int* → 0xB010"]
    R1["matrix[1] (купа)<br/>int* → 0xC200"]
    R2["matrix[2] (купа)<br/>int* → 0xD500"]

    D0["[0,0]=0  [0,1]=1  [0,2]=2  [0,3]=3<br/>0xB010...0xB01F"]
    D1["[1,0]=10 [1,1]=11 [1,2]=12 [1,3]=13<br/>0xC200...0xC20F"]
    D2["[2,0]=20 [2,1]=21 [2,2]=22 [2,3]=23<br/>0xD500...0xD50F"]

    M --> R0
    M --> R1
    M --> R2
    R0 --> D0
    R1 --> D1
    R2 --> D2

    style M fill:#f59e0b,color:#000
    style R0 fill:#3b82f6,color:#fff
    style R1 fill:#3b82f6,color:#fff
    style R2 fill:#3b82f6,color:#fff
    style D0 fill:#22c55e,color:#fff
    style D1 fill:#22c55e,color:#fff
    style D2 fill:#22c55e,color:#fff

Зверніть увагу: matrix[0], matrix[1] і matrix[2] вказують на різні, не суміжні ділянки купи. Це принципова відмінність від статичного масиву int arr[3][4], де всі 12 елементів розміщені в одній неперервній ділянці пам'яті. Ця несуміжність означає:

• Перевага: кожен рядок може мати різну довжину (так звані «зубчасті», або jagged-масиви).
• Недолік: через відсутність locality of reference (просторової локалізації) кеш процесора використовується менш ефективно порівняно з суцільними масивами.

Альтернатива: «сплющений» одновимірний масив

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

#include <iostream>

// Перетворення 2D-індексів на 1D
int getIndex(int row, int col, int numCols)
{
    return row * numCols + col;
}

int main()
{
    int rows = 3;
    int cols = 4;

    // Один виклик new замість rows+1 викликів
    int* matrix = new int[rows * cols];

    // Заповнення через допоміжну функцію
    for (int r = 0; r < rows; ++r)
        for (int c = 0; c < cols; ++c)
            matrix[getIndex(r, c, cols)] = r * 10 + c;

    // Доступ через getIndex()
    std::cout << "matrix[1][3] = " << matrix[getIndex(1, 3, cols)] << '\n'; // 13

    // Один виклик delete[]
    delete[] matrix;
    return 0;
}

Переваги «сплюснутого» підходу:

• Один виклик new і один delete[] — менше шансів на витік.
• Всі дані в суміжній пам'яті — кеш процесора задоволений.
• Простіше для компілятора оптимізувати.

Глибокі рівні вкладеності: int*** і далі

Концептуально нічого не заважає додати ще один рівень непрямості:

int***  ptr3; // вказівник на вказівник на вказівник
int**** ptr4; // і ще глибше...

Тривимірний масив через int*** будувався б за аналогічною схемою: масив вказівників на int**, кожен із яких є масивом вказівників на int*, а кожен з тих — масив int. Кількість викликів new і delete зростає експоненційно, а складність коду стрімко збільшується.

Порівняння підходів до двовимірних масивів

Практика та підсумок

Практичні завдання

int val = 5;
int** pp = &&val; // помилка компіляції

Підсумок

У наступній статті ми розглянемо оператор -> (доступ до членів через вказівник) — лаконічний синтаксичний цукор, без якого неможливо комфортно працювати зі структурами та об'єктами через вказівники.