Что означает «разыменование» указателя в C/C++?

Что такое разыменование указателя?

Разыменование (dereferencing) — это операция получения значения, на которое указывает указатель. Если указатель — это «листок с адресом дома», то разыменование — это фактический поход по этому адресу и взаимодействие с тем, что там находится.

Оператор разыменования — унарная звёздочка *. Она работает как обратная операция к взятию адреса &:

• &x — «дай мне адрес, где лежит x»
• *ptr — «возьми адрес из ptr и дай мне доступ к тому, что там лежит»

Ключевое отличие

Представьте переменную int x = 42 как коробку с числом 42. Указатель int* ptr = &x — это стикер с адресом этой коробки. Когда вы пишете:

std::cout << ptr;   // выводит адрес коробки (например, 0x7ffee1a2)
std::cout << *ptr;  // выводит содержимое коробки (42)

Разыменование позволяет вам читать и изменять содержимое по адресу:

*ptr = 100;  // теперь x = 100, потому что мы изменили значение по адресу ptr
std::cout << x;  // выведет 100

Зачем нужно разыменование?

Прямое использование переменной — это хорошо, но указатели дают гибкость:

1. Передача больших объектов в функции без копирования:

   void process(struct BigData* data) {
       (*data).field = 42;  // или data->field = 42 (то же самое)
   }

2. Динамическая память (new/delete):

   int* p = new int(10);
   *p = 20;  // разыменовываем, чтобы изменить значение в куче
   delete p;

3. Работа с массивами: arr[3] — это синтаксический сахар для *(arr + 3).
4. Изменение аргументов функции (передача по указателю):

   void swap(int* a, int* b) {
       int temp = *a;  // разыменовываем a
       *a = *b;
       *b = temp;
   }

Двойные указатели и их разыменование

int** ptr2 — это указатель на указатель. Представьте: у вас есть коробка с числом (x), стикер с адресом этой коробки (ptr), и ещё один стикер с адресом первого стикера (ptr2).

Разыменование работает пошагово:

int x = 42;
int* ptr = &x;
int** ptr2 = &ptr;

// *ptr2 — это ptr (указатель на x)
// **ptr2 — это x (значение 42)

**ptr2 = 100;  // меняем x на 100 через двойной указатель

Это используется, например, для изменения самого указателя внутри функции:

void allocate(int** p) {
    *p = new int(42);  // разыменовываем p, чтобы изменить внешний указатель
}

int* myPtr = nullptr;
allocate(&myPtr);  // теперь myPtr указывает на динамическую память

Важные предостережения

• Никогда не разыменовывайте нулевой указатель (nullptr) — это приведёт к крашу программы (segmentation fault).
• Проверяйте указатель перед разыменованием:

  if (ptr != nullptr) {
      *ptr = 42;
  }

• Разыменование не создаёт копию — вы работаете напрямую с оригиналом.

В современных C++ стараются использовать ссылки (&) и умные указатели (std::unique_ptr, std::shared_ptr), но понимание сырых указателей и разыменования — база, без которой не обойтись при работе с системным программированием, встраиваемыми системами или оптимизацией производительности.

struct Point { int x, y; };
Point p = {10, 20};
Point* ptr = &p;

// Оба варианта эквивалентны:
(*ptr).x = 30;   // классическое разыменование
ptr->x = 30;     // через оператор "стрелка"

int* p;   // объявление: p — указатель на int
*p = 5;   // разыменование: записать 5 по адресу, который хранит p