---
title: Память, указатели и управление ресурсами
seo:
description: >-
Тема «Память, указатели и управление ресурсами» для собеседования C++
Developer. В чем разница между указателем и ссылкой? Для чего нужен
указатель на функцию? Как его объявить?
title: Память, указатели и управление ресурсами — C++ Developer
---
[Все темы C++ Developer](/prep/c-developer)
Подтемы:
- [Память и указатели](#q-14bee738d69b81c1bc98db4a99b620c7)
- [Память](#q-14bee738d69b818cb0e6f8336eddfa57)
- [Указатели](#q-14bee738d69b812b947bf245f3ebffa9)
- [Управление памятью](#q-14bee738d69b818c8cabf6a269c27e12)
## В чем разница между указателем и ссылкой? [#q-14bee738d69b81c1bc98db4a99b620c7]
Основные различия между указателем и ссылкой в C++:
{/* prettier-ignore */}
1. Синтаксис и использование:
- Указатель: Переменная, которая хранит адрес другой переменной.
```cpp
int a = 10;
int* ptr = &a;
```
- Ссылка: Альтернативное имя для уже существующей переменной.
```cpp
int a = 10;
int& ref = a;
```
1. Инициализация:
- Указатель: Может быть инициализирован позже или изменён для указания на другой адрес.
```cpp
int b = 20;
ptr = &b; // Теперь ptr указывает на b
```
- Ссылка: Должна быть инициализирована сразу при создании и не может быть изменена для ссылок на другой объект.
```cpp
int c = 20;
ref = c; // Изменяет значение a на 20, но ref по-прежнему ссылается на a
```
1. Нулевое значение:
- Указатель: Может быть нулевым (nullptr), что означает, что он не указывает ни на какой объект.
```cpp
int* ptr = nullptr;
```
- Ссылку нужно связать с подходящим объектом или функцией. Сам язык не отслеживает время жизни цели: после её уничтожения ссылка может стать висячей.
1. Операции разыменования:
- Указатель: Требует операцию разыменования (*) для доступа к значению, на которое указывает.
```cpp
int value = *ptr;
```
- Ссылка: Не требует специальной операции для доступа к значению.
```cpp
int value = ref;
```
Указатель можно переназначить и проверить на nullptr. Ссылка удобна как обязательный параметр и не переназначается, но не гарантирует время жизни объекта. В обоих случаях нужно избегать висячих обращений.
:::note[Ссылки для изучения]
1. [Ссылки. Указатели. Константность](https://education.yandex.ru/handbook/cpp/article/references-pointers-const)
2. [Указатели и ссылки C++. #SimpleCode, с 0:08](https://www.youtube.com/watch?v=hZOX-LlUETE&t=8s)
:::
---
## Для чего нужен указатель на функцию? Как его объявить? [#q-14bee738d69b81e6bbe3f7c6f01b4e1e]
Указатель на функцию используется для хранения адреса функции и позволяет вызывать функции через этот указатель. Это полезно для реализации обратных вызовов (callbacks), таблиц виртуальных функций и гибких механизмов обработки событий.
#### Объявление указателя на функцию:
{/* prettier-ignore */}
1. Объявление:
- Для функции с прототипом void foo(int):
```cpp
void (*funcPtr)(int);
```
1. Инициализация:
- Присвоение адреса функции указателю:
```cpp
funcPtr = foo;
```
1. Использование:
- Вызов функции через указатель:
```cpp
funcPtr(5); // Вызывает foo(5)
```
Пример:
```cpp
#include // Обычная функция
void foo(int x) {
std::cout << "Value: " << x << std::endl;
}
int main() {
// Объявление указателя на функцию
void (*funcPtr)(int);
// Инициализация указателя адресом функции foo
funcPtr = foo;
// Вызов функции через указатель
funcPtr(5);
return 0;
}
```
:::note[Ссылки для изучения]
1. [Объявление и вызов указателя на функцию C++](https://metanit.com/cpp/tutorial/4.8.php)
:::
---
## Что будет, если забыть вызвать delete? Когда освободится та память? [#q-14bee738d69b81058d8bca82b37832a2]
Если забыть вызвать delete для динамически выделенной памяти, произойдёт утечка памяти (memory leak). В таком случае:
- Память, выделенная с помощью new, не будет освобождена.
- Память будет занята до завершения программы.
- Постепенно такие утечки могут привести к исчерпанию доступной памяти, что может вызвать замедление или крах программы.
Память, не освобождённая через delete, будет освобождена операционной системой при завершении программы, но в процессе выполнения программы эта память останется недоступной для повторного использования.
:::note[Ссылки для изучения]
1. [Утечки динамической памяти и владение ресурсом через RAII](https://education.yandex.ru/handbook/cpp/article/raii-and-smart-pointers)
:::
---
## Что такое умный указатель? Какие умные указатели есть в стандартной библиотеке? [#q-14bee738d69b813880eee005470557e1]
Умный указатель хранит указатель и реализует правила владения. unique_ptr освобождает ресурс при уничтожении или reset, shared_ptr при исчезновении последнего владельца. weak_ptr не владеет объектом и сам его не освобождает.
1. std::unique_ptr: Эксклюзивное владение ресурсом.
Не может быть скопирован, только перемещён.
1. std::shared_ptr: Совместное владение ресурсом.
Поддерживает подсчёт ссылок, освобождает память, когда последний
shared_ptr выходит из области видимости.
1. std::weak_ptr: Неблокирующая ссылка на ресурс,
управляемый std::shared_ptr. Не увеличивает подсчёт
ссылок.
Пример:
```cpp
#include
std::unique_ptr ptr1(new int(10));
std::shared_ptr ptr2 = std::make_shared(20);
std::weak_ptr ptr3 = ptr2;
```
:::note[Ссылки для изучения]
1. [RAII, unique_ptr и shared_ptr в C++](https://education.yandex.ru/handbook/cpp/article/raii-and-smart-pointers)
:::
---
## Как работает const для переменных, ссылок и указателей и от чего зависит размер указателя? [#q-14bee738d69b8165be4efb4c60b3dc73]
Константность переменной, ссылки, указателя:
- Константная переменная: Значение не может быть изменено
после инициализации.
```cpp
const int a = 10;
```
- Константная ссылка: Ссылка на константу, через которую
нельзя изменить значение.
```cpp
const int& ref = a;
```
- Константный указатель: Указатель, адрес которого нельзя
изменить после инициализации.
```cpp
int value = 10;
int* const ptr = &value;
```
- Указатель на константу: Указатель на значение, которое
нельзя изменить через этот указатель.
```cpp
const int* ptr = &a;
```
Константный указатель и указатель на константу:
- Константный указатель (
int* const
): Указатель не может указывать на другой адрес, но
данные по этому адресу могут изменяться.
```cpp
int value = 10;
int* const ptr = &value;
```
- Указатель на константу (
const int*
): Указатель может менять адрес, но данные по адресу
менять нельзя.
```cpp
const int* ptr = &a;
```
Размер указателя:
- Размер указателя определяется типом указателя и реализацией; проверяйте sizeof. Следующие размеры типичны для распространённых ABI, но не гарантированы стандартом для всех платформ и указателей на члены.
- 32-битная система: Указатель занимает 4 байта.
- 64-битная система: Указатель занимает 8 байт.
:::note[Ссылки для изучения]
1. [Ссылки. Указатели. Константность](https://education.yandex.ru/handbook/cpp/article/references-pointers-const)
:::
---
## Что случится, если вернуть ссылку на временный объект? [#q-14bee738d69b819a87f6ed9bbd2ac281]
Если вернуть ссылку на временный объект, то после завершения функции объект будет уничтожен, и ссылка станет "висячей" (dangling reference). Использование такой ссылки приведёт к неопределённому поведению, что может вызвать ошибки или сбои программы.
:::note[Ссылки для изучения]
1. [Ссылки. Указатели. Константность](https://education.yandex.ru/handbook/cpp/article/references-pointers-const)
:::
---
## Где может храниться переменная? [#q-14bee738d69b818cb0e6f8336eddfa57]
В языке программирования C переменные могут храниться в различных областях памяти, каждая из которых имеет свои особенности по времени жизни и области видимости. Вот основные места хранения переменных:
{/* prettier-ignore */}
1. Стек (Stack): Локальные переменные внутри функций обычно хранятся на стеке. Они создаются при вызове функции и уничтожаются при её завершении.
1. Куча (Heap): Динамически выделенная память (через malloc, calloc, realloc и другие функции) находится в куче. Переменные в куче сохраняются до тех пор, пока не будут освобождены с помощью free.
1. Глобальная память (Global Area): Глобальные и статические переменные хранятся в глобальной области памяти. Они инициализируются при запуске программы и существуют до её завершения.
1. Регистры (Registers): Компилятор может оптимизировать программу, помещая некоторые переменные непосредственно в регистры процессора для быстрого доступа.
1. Литеральный пул (Literal Pool): Константы, такие как строковые литералы, обычно хранятся в отдельной области памяти, оптимизированной для неизменяемых данных.
:::note[Ссылки для изучения]
1. [Стековое время жизни, динамические объекты и static в C++](https://education.yandex.ru/handbook/cpp/article/object-lifetime)
:::
---
## Какая разница между calloc и malloc? [#q-14bee738d69b819fbcb8c0d7954f9f9d]
Функции calloc и malloc используются в языке программирования C для динамического выделения памяти, но они работают немного по-разному:
{/* prettier-ignore */}
1. malloc (Memory Allocation):
- Принцип работы: Выделяет блок памяти заданного размера.
- Инициализация: Память, выделенная с помощью malloc, не инициализируется. Это означает, что начальные значения в выделенной памяти не определены (могут быть мусорные значения).
- Синтаксис: void* malloc(size_t size);
- Пример: int* ptr = malloc(10 * sizeof(int)); выделит память для 10 целочисленных значений, но не инициализирует их.
1. calloc (Contiguous Allocation):
- Принцип работы: Выделяет блок памяти для массива элементов заданного размера и количества.
- Инициализация: Память, выделенная с помощью calloc, автоматически инициализируется нулями.
- Синтаксис: void* calloc(size_t num, size_t size);
- Пример: int* ptr = calloc(10, sizeof(int)); выделит память для 10 целочисленных значений и инициализирует их нулями.
Основное отличие между malloc и calloc заключается в инициализации: calloc инициализирует выделенную память нулями, в то время как malloc оставляет память неинициализированной.
:::note[Ссылки для изучения]
1. [malloc в библиотеке времени выполнения C++](https://learn.microsoft.com/ru-ru/cpp/c-runtime-library/reference/malloc?view=msvc-170)
1. [calloc: выделение массива с нулевым заполнением](https://learn.microsoft.com/ru-ru/cpp/c-runtime-library/reference/calloc?view=msvc-170)
:::
---
## Что такое указатель? [#q-14bee738d69b812b947bf245f3ebffa9]
Указатель в программировании, особенно в языках C и C++, — это переменная, которая хранит адрес памяти другой переменной. Указатели используются для следующих целей:
1. Доступ к данным: Указатель позволяет прямой доступ к
данным, на которые он указывает, что может использоваться для изменения этих
данных.
1. Управление памятью: С помощью указателей можно
динамически выделять и освобождать память во время выполнения программы.
1. Работа с массивами и строками: Указатели обеспечивают
эффективный способ обработки массивов и строк.
1. Передача аргументов по ссылке: Указатели позволяют
функциям изменять значения переданных переменных и работать с большими
структурами данных без значительных затрат на копирование.
1. Создание сложных структур данных: Указатели используются
для создания связанных структур данных, таких как списки, деревья и графы.
Указатель определяется в C с использованием символа звездочки \*, а доступ к значению, на которое он указывает, осуществляется через оператор разыменования \*. Получение адреса переменной для сохранения в указателе выполняется с помощью оператора адреса &.
:::note[Ссылки для изучения]
1. [Указатели и ссылки в C++: адрес, разыменование и nullptr](https://education.yandex.ru/handbook/cpp/article/references-pointers-const)
2. [Указатели и ссылки C++. #SimpleCode, с 0:08](https://www.youtube.com/watch?v=hZOX-LlUETE&t=8s)
:::
---
## Какой размер имеет указатель и от чего он зависит? [#q-14bee738d69b81ceae57e8fd2d6630f4]
Размер указателя в языках программирования, таких как C и C++, зависит от архитектуры системы, на которой выполняется программа. Обычно размер указателя равен:
- 32 бита (4 байта) на 32-битных системах.
- 64 бита (8 байт) на 64-битных системах.
Это связано с тем, что размер указателя должен быть достаточным для хранения максимально возможного адреса памяти, который может быть использован в данной архитектуре. Таким образом, размер указателя напрямую зависит от размера адресного пространства операционной системы и аппаратной архитектуры.
:::note[Ссылки для изучения]
1. [Почему размер указателя на метод C++ зависит от реализации](https://habr.com/ru/articles/333334/)
:::
---
## Какие есть операции с указателями? [#q-14bee738d69b8188ad14fc48a704dcd6]
Операции с указателями в языках программирования, таких как C и C++, позволяют манипулировать адресами и данными, на которые указывают эти адреса. Вот основные операции, которые можно выполнять с указателями:
1. Присваивание: Установка адреса переменной в указатель.
```cpp
int a = 10;
int* ptr = &a; // Указатель ptr теперь указывает на a.
```
1. Разыменование: Доступ к данным по адресу, хранящемуся в
указателе.
```cpp
int value = *ptr; // value теперь равно 10, значение a.
```
1. Сдвиг указателя: Прибавление целого n смещает указатель на n элементов в пределах одного массива, включая позицию сразу после конца. Разыменовывать позицию после конца нельзя.
```cpp
ptr++; // Перемещение на следующий адрес, типично для типа данных (например, на 4 байта вперед для int во многих системах).
```
1. Сравнение: Сравнение адресов, хранящихся в указателях.
```cpp
if (ptr1 == ptr2) // Проверка, указывают ли два указателя на одно и то же место в памяти.
```
1. Арифметика указателей: Вычисление разницы между двумя
указателями, что дает количество элементов между ними.
```cpp
int* ptr1 = &a[10];
int* ptr2 = &a[5];
int n = ptr1 - ptr2; // n будет равно 5, если ptr1 и ptr2 указывают на элементы одного массива.
```
1. Получение адреса: Использование оператора
& для получения адреса переменной.
```cpp
int* ptr = &a; // Получение адреса переменной a.
```
:::note[Ссылки для изучения]
1. [Указатели и ссылки в C++: адрес, разыменование и nullptr](https://education.yandex.ru/handbook/cpp/article/references-pointers-const)
:::
---
## Чем отличаются delete и delete[]? Что случится, если вызвать delete у объекта, созданного через new[]? [#q-14bee738d69b818c8cabf6a269c27e12]
Отличия delete и
delete[]
:
- delete: Используется для освобождения памяти, выделенной для
одиночного объекта с помощью new.
```cpp
int* p = new int;
delete p;
```
- delete[]: Используется для освобождения памяти,
выделенной для массива объектов с помощью new[].
```cpp
int* arr = new int[10];
delete[] arr;
```
Использование delete вместо
delete[] для объекта, созданного через
new[]
, приводит к неопределённому поведению. Это может вызвать:
- Неполное освобождение памяти (утечка памяти).
- Потенциальные ошибки выполнения или сбои программы.
#### Рекомендация:
Всегда использовать delete[] для освобождения памяти, выделенной с помощью new[], чтобы избежать неопределённого поведения и корректно освободить всю выделенную память.
:::note[Ссылки для изучения]
1. [delete, new\[\] в C++ и городские легенды об их сочетании](https://habr.com/ru/companies/contentai/articles/117208/)
:::
---
## Что такое memory leak? [#q-14bee738d69b815f81bec733a1e5292b]
Memory leak (утечка памяти) — это ситуация, когда программа
выделяет память динамически (например, с помощью new или
malloc), но не освобождает её (с помощью delete или
free). В результате, используемая память остаётся занятой и
недоступной для повторного использования, что может привести к исчерпанию
доступной памяти и замедлению или краху программы.
:::note[Ссылки для изучения]
1. [Утечки динамической памяти и владение ресурсом через RAII](https://education.yandex.ru/handbook/cpp/article/raii-and-smart-pointers)
:::