Умные указатели в C++: Полное руководство

Умные указатели в C++ — это объекты, которые автоматически управляют динамическим выделением и освобождением памяти, предотвращая распространенные ошибки управления памятью, такие как утечки памяти и висячие указатели. Вы должны использовать умные указатели всякий раз, когда вам нужно управлять временем жизни динамически выделенных объектов, особенно при работе со сложными сценариями владения, общими ресурсами или когда вы хотите полностью исключить ручное управление памятью.

Содержание

• Что такое умные указатели?
• Типы умных указателей в современном C++
• Когда использовать умные указатели
• Когда НЕ использовать умные указатели
• Лучшие практики использования умных указателей
• Практические примеры

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

Умные указатели — это интеллектуальные классы-обертки, которые ведут себя как обычные указатели, но автоматически управляют временем жизни динамически выделенных объектов. Они обеспечивают автоматическое освобождение памяти, когда объект больше не нужен, устраняя необходимость в ручных операциях delete. Основная цель умных указателей — решить распространенные проблемы управления памятью в C++, гарантируя, что выделенная память правильно освобождается.

Умные указатели используются для гарантии удаления объекта, если он больше не используется (на него нет ссылок).

Ключевое преимущество умных указателей заключается в том, что они инкапсулируют логику управления памятью, делая код более безопасным и менее подверженным ошибкам. Согласно документации Microsoft Learn, умные указатели “автоматически управляют временем жизни динамически выделенного объекта” и помогают предотвратить распространенные проблемы, связанные с сырыми указателями.

Умные указатели достигают этого, реализуя принципы RAII (Resource Acquisition Is Initialization), где получение ресурса (выделение памяти) происходит во время конструирования объекта, а освобождение ресурса (освобождение памяти) — во время уничтожения.

Типы умных указателей в современном C++

Современный C++ (C++11 и новее) предоставляет три основных типа умных указателей в заголовке <memory>:

std::unique_ptr

std::unique_ptr обеспечивает исключительное владение динамически выделенным объектом. Только один unique_ptr может владеть объектом в любой момент времени, и когда unique_ptr выходит из области видимости, объект автоматически удаляется.

• Ключевые характеристики: Не копируемый, перемещаемый, легковесный
• Производительность: Нет накладных расходов (как и у сырого указателя)
• Случай использования: Сценарии с единоличным владением

Как объясняется на Internal Pointers, “Технически это происходит потому, что у std::unique_ptr нет конструктора копирования: это может быть очевидно для вас, если вы знакомы с семантикой перемещения.”

std::shared_ptr

std::shared_ptr позволяет нескольким указателям совместно владеть одним и тем же объектом с использованием подсчета ссылок. Объект удаляется только тогда, когда последний shared_ptr, указывающий на него, уничтожается.

• Ключевые характеристики: Копируемый, подсчет ссылок, немного тяжелее
• Производительность: Накладные расходы из-за подсчета ссылок
• Случай использования: Сценарии с совместным владением

Согласно Stack Overflow, “shared_ptr — это указатель на T, использующий подсчет ссылок для определения, когда объект больше не нужен.”

std::weak_ptr

std::weak_ptr — это не владеющий умный указатель, который предоставляет доступ к объекту, управляемому shared_ptr, без увеличения счетчика ссылок. Он используется для разрыва циклических зависимостей и наблюдения за объектами без их сохранения в живом состоянии.

• Ключевые характеристики: Не владеющий, не увеличивает счетчик ссылок
• Производительность: Нет накладных расходов, кроме связанного с ним shared_ptr
• Случай использования: Разрыв циклических зависимостей, паттерны наблюдателя

Как указано на Codecademy, “std::weak_ptr используется совместно с разделяемым указателем, но, в отличие от разделяемого указателя, он не увеличивает счетчик ссылок.”

Устаревший: std::auto_ptr

std::auto_ptr был предшественником современных умных указателей, но был объявлен устаревшим в C++11 и удален в C++17 из-за проблемных семантик копирования. В современном коде следует избегать его использования.

Когда использовать умные указатели

Умные указатели следует использовать в следующих сценариях:

Управление динамической памятью

Всякий раз, когда вам нужно динамически выделять память с помощью new, вы должны рассмотреть возможность использования умного указателя вместо сырого указателя. Это особенно верно для объектов, время жизни которых должно превышать текущую область видимости.

Как указано на cppreference.com, умные указатели используются “для гарантии удаления объекта, если он больше не используется (на него есть ссылки).”

Управление временем жизни ресурса

Умные указатели идеальны, когда вам нужно связать время жизни объекта с определенной областью видимости или контейнером. Как объясняется в C++ Core Guidelines, “Область действия указателей полезна, когда вы хотите связать время жизни объекта с определенным блоком кода, или если вы встроили его как член данных в другой объект, время жизни этого другого объекта.”

Сценарии совместного владения

Когда нескольким частям вашей программы нужен доступ к одному и тому же ресурсу, std::shared_ptr предоставляет чистый и безопасный способ управления этим совместным владением.

Согласно руководству по программированию Университета Дьюка, “Он поддерживает счетчик ссылок для управления временем жизни ресурса, уничтожая его, когда последний shared_ptr уничтожается или сбрасывается… Подходит для сценариев, в которых нескольким частям программы необходимо совместно использовать доступ к ресурсу.”

Переменные-члены класса

Умные указатели отлично подходят в качестве переменных-членов класса, когда класс владеет объектом. Это обеспечивает правильную очистку даже в случае возникновения исключений.

Фабричные функции

Когда фабричные функции возвращают динамически выделенные объекты, возвращение умных указателей вместо сырых указателей безопасно передает владение.

Безопасность при исключениях

Умные указатели обеспечивают автоматическую очистку даже при возникновении исключений, делая ваш код более надежным.

Когда НЕ использовать умные указатели

Несмотря на их преимущества, умные указатели не подходят для всех ситуаций:

Не владеющие ссылки

Когда вам нужна ссылка на объект, но вы не хотите брать на себя владение, используйте сырые указатели или ссылки вместо умных указателей. Как объясняется на Stack Overflow, “В этом случае совершенно нормально не использовать умный указатель вместо него, потому что вы не хотите управлять временем жизни объекта.”

Критически важный для производительности код

В коде, где критически важна производительность, даже небольшие накладные расходы подсчета ссылок (в shared_ptr) могут быть неприемлемы, и в этом случае могут быть более подходящими сырые указатели. Однако это должно быть взвешенное решение.

Взаимодействие с C API

При работе с C API, которые ожидают сырые указатели, вам придется использовать сырые указатели. Однако вы все равно можете использовать умные указатели для управления временем жизни на стороне C++.

Короткоживущие объекты

Для очень короткоживущих объектов в хорошо определенных блоках область действия накладные расходы умных указателей могут быть неоправданными. Как предлагается на Microsoft Learn, “В современном C++ сырые указатели используются только в небольших блоках кода с ограниченной областью действия, циклах или вспомогательных функциях, где производительность критична и нет путаницы с владением.”

Контейнеры STL

Стандартные контейнеры (такие как std::vector, std::map и т.д.) уже управляют своей собственной памятью, поэтому обычно нет необходимости использовать умные указатели для хранения их элементов.

Лучшие практики использования умных указателей

Используйте фабричные функции

Предпочитайте std::make_unique и std::make_shared для создания умных указателей:

// Хорошо
auto ptr = std::make_unique<MyClass>(args);

// Не так хорошо
auto ptr = std::unique_ptr<MyClass>(new MyClass(args));

Передавайте умные указатели соответствующим образом

• Передавайте по значению при передаче владения
• Передавайте по константной ссылке при наблюдении
• Передавайте сырые указатели или ссылки, когда функция не берет владение

Как указано в документации Microsoft, “В большинстве случаев, когда вы инициализируете сырой указатель или дескриптор ресурса, чтобы он указывал на реальный ресурс, передайте указатель умному указателю немедленно.”

Избегайте циклических зависимостей

Используйте std::weak_ptr для разрыва циклических ссылок, которые бы предотвращали удаление объектов.

Используйте пользовательские удалители при необходимости

Умные указатели могут быть настроены с помощью пользовательских удалителей для специальных потребностей управления ресурсами.

Предпочитайте уникальные указатели разделяемым

Когда это возможно, отдавайте предпочтение std::unique_ptr вместо std::shared_ptr, так как у него нет накладных расходов и более ясная семантика владения.

Не злоупотребляйте умными указателями

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

Практические примеры

Базовое использование уникального указателя

#include <memory>

void process_data() {
    auto data = std::make_unique<Data>(/* аргументы */);
    // Используйте data...
    // Нет необходимости в delete - происходит автоматически при выходе data из области видимости
}

Разделяемый указатель для общих ресурсов

#include <memory>

class ResourceManager {
public:
    void add_client(std::shared_ptr<Resource> resource) {
        clients.push_back(resource);
    }
private:
    std::vector<std::shared_ptr<Resource>> clients;
};

Разрыв циклических зависимостей

class Node {
public:
    void set_parent(std::shared_ptr<Node> parent) {
        parent_ = parent;
        parent_->add_child(std::weak_ptr<Node>(shared_from_this()));
    }
    
private:
    std::shared_ptr<Node> parent_;
    std::vector<std::weak_ptr<Node>> children_;
};

Пример фабричной функции

std::unique_ptr<Database> create_database(const std::string& config) {
    return std::make_unique<Database>(config);
}

void use_database() {
    auto db = create_database("config.ini");
    // Используйте базу данных
    // Память автоматически очищается
}

Заключение

Умные указатели являются незаменимым инструментом для современной разработки на C++, который обеспечивает автоматическое управление памятью при сохранении производительности и безопасности. Они представлены в трех основных разновидностях: std::unique_ptr для исключительного владения, std::shared_ptr для совместного владения с подсчетом ссылок и std::weak_ptr для не владеющих ссылок. Вы должны использовать умные указатели всякий раз, когда управляете динамически выделенными объектами, особенно в переменных-членах класса, фабричных функциях или при работе со сложными сценариями владения. Однако они не подходят для не владеющих ссылок, критически важного для производительности кода или короткоживущих объектов в хорошо определенных блоках. Следуя лучшим практикам, таким как использование фабричных функций и избегание циклических зависимостей, вы можете использовать умные указатели для написания более безопасного и поддерживаемого кода на C++.

Источники

1. Smart pointers (Modern C++) | Microsoft Learn
2. Smart pointers in C++ - GeeksforGeeks
3. What is a smart pointer and when should I use one? - Stack Overflow
4. smart pointers - cppreference.com
5. Guide over Smart Pointers in C++ - Medium
6. Smart pointer - Wikipedia
7. A beginner’s look at smart pointers in modern C++ - Internal Pointers
8. Smart Pointers in C++ - Scaler Topics
9. Smart Pointers - Intel
10. Smart Pointers In C++ - GeeksProgramming
11. Smart Pointers - Boost
12. An introduction to smart pointers in C++ - Medium
13. C++ (C Plus Plus) | Smart Pointers | Codecademy
14. Modern memory management using smart pointers in C++23 - Part 1 - Incredibuild
15. When to use smart pointers in real life? - C++ Forum