Указатели и память

У переменной можно обсуждать как минимум две разные вещи: её значение и место, по которому к объекту можно обратиться. Для int x = 7; значение — это семь, а выражение &x даёт адрес объекта. Указатель связывает эти идеи: он хранит адрес, а операция разыменования позволяет обратиться к расположенному по нему объекту. Это связь с исходным объектом, а не отдельная копия его числа.

Для начала удобно представлять оперативную память как ряд ячеек, каждая из которых имеет адрес. Переменная x занимает место, а &x позволяет получить её адрес. Указатель p хранит этот адрес, но сам тоже является отдельной переменной.

#include <iostream>
int main() {
    int x = 7;
    int* p = &x;    // адрес x
    std::cout << p << '\n';  // адрес (зависит от запуска)
    std::cout << *p << '\n'; // 7
}

После int* p = &x; изменение x не требует заново записывать его адрес в p. Объект остаётся тем же, меняется только его содержимое. В обратную сторону связь тоже работает: запись *p = 25; меняет x. При этом у самого p есть собственный адрес &p, потому что указатель тоже хранится как самостоятельный объект.

#include <iostream>

int main() {
    int value = 7;
    int* pointer = &value;
    *pointer = 25;
    std::cout << value << ' ' << *pointer << '\n';
}

#include <iostream>

int main() {
    int value = 3;
    int* first = &value;
    int* second = first;
    *second += 4;
    std::cout << std::boolalpha << (first == second) << '\n';
    std::cout << value << ' ' << *first << '\n';
}

Полезно проговаривать эти две операции словами: &x — «получить адрес x», а *p — «обратиться к объекту по адресу из p». Так легче не перепутать указатель и данные, к которым он ведёт. В частности, получение адреса не читает копию всего объекта, а разыменование предоставляет возможность работать с самим объектом при выполнении необходимых условий.

Пусть p и q содержат адрес одного int. Тогда присваивание через *q будет видно и при чтении через *p: оба выражения обращаются к одному объекту. Но присваивание q = &y; изменит уже сам указатель q и перенаправит его на другой объект. Сравнивайте левую часть записи: q и *q обозначают разные объекты.

int x = 5;
int* p = &x;
*p = 25;        // меняет x
// теперь x == 25

int* q = p;     // копия адреса
*q = 30;       // тоже меняет x

Для корректного указателя p на живой объект выражение &(*p) получает исходный адрес. Но разыменовывать случайный или нулевой указатель ради такой операции нельзя.

Почему нельзя написать &(x + 1)? Унарный & для обычных объектов требует подходящее lvalue, тогда как x + 1 даёт временный prvalue. ?Техническая оговоркаЭто учебное правило для встроенного оператора взятия адреса. В C++ есть перегруженный operator& у пользовательских типов и особые варианты выражений; подробности будут позднее.

Разобранный пример и самостоятельная проверка

У нас есть объект x со значением семь и другой объект p, который хранит указатель на x. Выражение x обозначает исходное целое число, а &x получает его адрес. Переменная p содержит этот адрес. Разыменование *p позволяет обратиться к самому x: это не копия числа. Поэтому присваивание через *p меняет x, а значение указателя p остаётся прежним. У самого p тоже есть адрес, который записывается как &p. Он относится к другому объекту и имеет другой тип: p является указателем на int, а &p — указателем на такой указатель. Пока нам достаточно различать эти роли, не разбирая несколько разыменований. Реальные адреса при запуске могут меняться, поэтому в проверках сравниваем отношения, а не конкретные шестнадцатеричные числа. Получение адреса не передаёт владение объектом. X существует как локальная переменная; вызывать delete для &x нельзя.

#include <iostream>

int main() {
    int x = 7;
    int* p = &x;
    *p = 25;
    std::cout << x << ' ' << *p << '\n';
    std::cout << std::boolalpha << (p == &x) << '\n';
    std::cout << "p: " << p << " address of p: " << &p << '\n';
}

Объект, адрес и доступ к значению

Для int x=25; int* p=&x; различайте пять выражений:

Наблюдающий указатель не владеет целью и не продлевает её время жизни. Перед разыменованием цель должна существовать, а адрес должен быть допустим. Адреса на рисунках условны.

Тип указателя сообщает компилятору, с каким типом объекта предполагается работать после разыменования. Это не декоративная подпись к напечатанному адресу: от типа зависят допустимые операции и смысл шага по массиву. Поэтому указатели разных типов нельзя считать взаимозаменяемыми только потому, что на выбранной платформе они занимают одинаковое количество байтов.

Объявления лучше читать по одной переменной. В int* first, second; звёздочка относится к декларатору first, а second имеет тип int. Если нужны два указателя, яснее написать два отдельных объявления. Также разделяйте размер объекта-указателя и размер указываемого объекта: адрес книги и сама книга — разные данные (аналогия помогает различать роли, но не описывает физическое устройство указателя).

int x = 9;
int* p = &x;
int* q = &x;    // два указателя

int* a, b;     // a: int*, b: int
// Лучше: одно объявление на строку

Обычная передача аргумента по значению создаёт отдельный параметр функции. Если передать число, функция получает своё число; если передать указатель, она получает свою копию адреса. Во втором случае обе копии адреса могут вести к одному исходному объекту. Поэтому функция способна изменить этот объект через разыменование, хотя сам параметр всё равно передан по значению.

Различайте *p = 10; и p = &other; внутри функции. Первая запись изменяет объект вызывающего кода, если передан его корректный адрес. Вторая перенаправляет только локальную копию указателя и не меняет переменную-указатель у вызывающей стороны. Когда требуется изменить именно её, пригодится дополнительный уровень косвенности из предыдущего раздела либо другой подходящий интерфейс функции.

#include <iostream>

void swap_values(int first, int second) {
    int temporary = first;
    first = second;
    second = temporary;
}

void swap_pointers(int* first, int* second) {
    int temporary = *first;
    *first = *second;
    *second = temporary;
}

int main() {
    int x = 1;
    int y = 2;
    swap_values(x, y);
    std::cout << x << ' ' << y << '\n';
    swap_pointers(&x, &y);
    std::cout << x << ' ' << y << '\n';
}

#include <iostream>

bool swap_if_present(int* first, int* second) {
    if (first == nullptr || second == nullptr) {
        return false;
    }
    int temporary = *first;
    *first = *second;
    *second = temporary;
    return true;
}

int main() {
    int value = 7;
    bool changed = swap_if_present(&value, nullptr);
    std::cout << std::boolalpha << changed << ' ' << value << '\n';
}

#include <iostream>
void swap_by_value(int a, int b) {
    int t = a; a = b; b = t;
}
void swap_by_ptr(int* a, int* b) {
    int t = *a;
    *a = *b;
    *b = t;
}
int main() {
    int x = 1, y = 2;
    swap_by_value(x, y);    // x = 1, y = 2
    swap_by_ptr(&x, &y);   // x = 2, y = 1
    std::cout << x << ' ' << y;
}

#include <cstdio>
int main() {
    int x = 0;
    if (std::scanf("%d", &x) != 1) {
        std::puts("Некорректный ввод");
        return 1;
    }
    std::printf("%d\n", x);
}

Арифметика указателей нужна прежде всего для движения по последовательным элементам одного массива. Если p указывает на первый элемент, p + 1 обозначает следующий элемент независимо от его размера в байтах. Такой шаг удобно сравнивать с переходом к следующему месту в ряду: важно число элементов, а пересчёт в размещение выполняется с учётом их типа.

Прибавление целого k к T* сдвигает указатель на k элементов типа T, а не на k байт. Это имеет смысл при обходе массива, где элементы гарантированно размещены подряд.

У массива из пяти элементов допустимы обращения к индексам от нуля до четырёх. Указатель begin + 5 можно сформировать как границу обхода, но по нему нельзя читать элемент: шестого объекта в массиве нет. Поэтому цикл обычно сначала сравнивает текущую позицию с концом и только затем разыменовывает её. Разность подходящих указателей показывает число шагов между ними, а не количество байтов.

#include <iostream>

int main() {
    int values[]{10, 20, 30};
    const int* end = values + 3;
    for (const int* current = values; current != end; ++current) {
        std::cout << *current << ' ';
    }
    std::cout << '\n';
}

#include <cstddef>
#include <iostream>

int main() {
    int values[]{10, 20, 30, 40, 50};
    int* first = &values[1];
    int* last = &values[3];
    std::ptrdiff_t distance = last - first;
    std::cout << distance << '\n';
    std::cout << *(first + 1) << '\n';
}

#include <iostream>
#include <vector>
int main() {
    std::vector<int> v{10, 20, 30, 40, 50};
    int* p = v.data();
    std::cout << *(p + 2) << '\n'; // 30
    std::cout << (&v[4] - &v[0]) << '\n'; // 4
    int* end = p + v.size();            // допустимо
    std::cout << (end - p) << '\n'; // 5
    // std::cout << *end;               // UB
}

Адрес не является обещанием, что объект будет существовать сколько угодно долго. Локальная переменная может закончить своё время жизни при выходе из блока, а сохранённое ранее значение указателя останется в другой переменной. Такое рассогласование и создаёт висячий указатель (у вас сохранился способ обратиться к объекту, но сам объект уже перестал существовать).

int* p = nullptr;
{
    int value = 42;
    p = &value;
}                      // value уничтожен
// *p = 5;                // UB: объект не жив
p = nullptr;             // больше не используем адрес

Следить нужно не только за локальными блоками. Контейнер тоже может переместить свои элементы при изменении внутреннего буфера, после чего старые адреса использовать нельзя. Например, после операции, вызвавшей перераспределение памяти vector, подходящий адрес следует получить заново. Присваивание nullptr может помочь явно обозначить отсутствие используемого объекта, но не восстанавливает его жизнь и не исправляет другие сохранённые копии старого указателя.

#include <iostream>

int main() {
    int* pointer = nullptr;
    {
        int value = 42;
        pointer = &value;
        std::cout << *pointer << '\n';
        pointer = nullptr;
    }
    std::cout << std::boolalpha << (pointer == nullptr) << '\n';
}

#include <iostream>
#include <vector>

int main() {
    std::vector<int> values{10, 20};
    int* pointer = values.data();
    std::cout << pointer[0] << '\n';
    values.push_back(30);
    pointer = values.data();
    std::cout << pointer[2] << '\n';
}

void* и nullptr решают разные задачи, хотя оба встречаются рядом с указателями. Первое позволяет хранить адрес объекта без указания его конкретного типа в этом указателе. Второе обозначает отсутствие объекта, на который можно было бы указывать. «Тип скрыт» не означает «объекта нет», а «указатель ненулевой» не означает «объект гарантированно пригоден для доступа».

#include <iostream>
int main() {
    int* p = nullptr;
    if (p == nullptr) {
        std::cout << "нет объекта\n";
    }
    int x = 3;
    p = &x;
    if (p) std::cout << *p << '\n';
}

int x = 20;
void* raw = &x;              // int* -> void*
// *raw;                     // ошибка компиляции
// raw + 1;                  // не стандартный C++
int* p = static_cast<int*>(raw);
*p = 21;                    // x == 21

Преобразование из void* обратно в int* не проводит проверку содержимого памяти. Оно уместно, когда вы уже знаете, что исходный адрес получен от подходящего живого int. С nullptr логика другая: функция может договориться считать его сигналом «аргумент отсутствует» и обработать этот случай до разыменования. Такой договор нужно соблюдать на стороне вызывающего кода.

#include <iostream>

void print(const int* pointer) {
    if (pointer == nullptr) {
        std::cout << "No object\n";
        return;
    }
    std::cout << *pointer << '\n';
}

int main() {
    int value = 3;
    print(nullptr);
    print(&value);
}

#include <iostream>

int main() {
    int value = 20;
    void* raw = &value;
    int* pointer = static_cast<int*>(raw);
    *pointer = 21;
    std::cout << value << '\n';
}

Указатель на указатель нужен, когда объектом, с которым требуется работать через адрес, сам является указатель. Это не особый способ хранения «более точного» адреса, а ещё один уровень связи. Если p хранит адрес числа, то pp = &p хранит адрес переменной p. По цепочке можно либо перенаправить указатель, либо изменить конечное число.

Указатель — это самостоятельный объект, а значит у него тоже есть адрес. Если p имеет тип int*, то &p имеет тип int**.

Разбирайте **pp двумя последовательными шагами. Первое * приводит к переменной-указателю p, второе — к объекту, на который она сейчас указывает. Поэтому *pp = &y; перенаправляет p на y, а последующее **pp = 12; записывает двенадцать уже в y. Во всех звеньях цепочки должны находиться корректные указатели на живые подходящие объекты.

#include <iostream>

int main() {
    int x = 5;
    int y = 9;
    int* pointer = &x;
    int** indirect = &pointer;
    *indirect = &y;
    **indirect = 12;
    std::cout << x << ' ' << y << '\n';
}

#include <iostream>

void select(int** destination, int* target) {
    *destination = target;
}

int main() {
    int value = 42;
    int* pointer = nullptr;
    select(&pointer, &value);
    std::cout << *pointer << '\n';
}

int x = 5;
int y = 9;
int* p = &x;
int** pp = &p;

**pp = 7;     // x становится 7
*pp = &y;     // p теперь указывает на y
**pp = 12;    // y становится 12