```c++ #include #include // Простой умный указатель для одного объекта (аналог std::unique_ptr) template class UniquePointer { public: // Конструктор, принимающий сырой указатель explicit UniquePointer(T* ptr = nullptr) : ptr_(ptr) {} // Деструктор ~UniquePointer() { delete ptr_; } // Запрещаем копирование и присваивание UniquePointer(const UniquePointer&) = delete; UniquePointer& operator=(const UniquePointer&) = delete; // Разрешаем перемещение UniquePointer(UniquePointer&& other) noexcept : ptr_(other.ptr_) { other.ptr_ = nullptr; } UniquePointer& operator=(UniquePointer&& other) noexcept { if (this != &other) { delete ptr_; ptr_ = other.ptr_; other.ptr_ = nullptr; } return *this; } // Доступ к объекту T* operator->() const { return ptr_; } T& operator*() const { return *ptr_; } // Получение сырого указателя T* get() const { return ptr_; } // Отсоединение указателя T* release() { T* temp = ptr_; ptr_ = nullptr; return temp; } // Замена сырого указателя void reset(T* ptr = nullptr) { if (ptr_ != ptr) { delete ptr_; ptr_ = ptr; } } // Проверка на нулевой указатель operator bool() const { return ptr_ != nullptr; } private: T* ptr_; // Сырой указатель }; // Простой умный указатель для одного или нескольких объектов с подсчетом ссылок (аналог std::shared_ptr) template class SharedPointer { private: T* ptr_; // Сырой указатель на объект(ы) std::atomic* ref_count_; // Указатель на счетчик ссылок (атомарный для потокобезопасности) public: // Конструктор по умолчанию SharedPointer() : ptr_(nullptr), ref_count_(nullptr) {} // Конструктор, принимающий сырой указатель explicit SharedPointer(T* ptr) : ptr_(ptr), ref_count_(new std::atomic(1)) {} // Конструктор копирования SharedPointer(const SharedPointer& other) : ptr_(other.ptr_), ref_count_(other.ref_count_) { if (ref_count_) { (*ref_count_)++; // Увеличиваем счетчик ссылок } } // Оператор присваивания копированием SharedPointer& operator=(const SharedPointer& other) { if (this != &other) { // Уменьшаем счетчик для текущего указателя перед переприсваиванием decrement_ref(); ptr_ = other.ptr_; ref_count_ = other.ref_count_; // Увеличиваем счетчик для нового указателя if (ref_count_) { (*ref_count_)++; } } return *this; } // Конструктор перемещения SharedPointer(SharedPointer&& other) noexcept : ptr_(other.ptr_), ref_count_(other.ref_count_) { other.ptr_ = nullptr; other.ref_count_ = nullptr; } // Оператор присваивания перемещением SharedPointer& operator=(SharedPointer&& other) noexcept { if (this != &other) { // Уменьшаем счетчик для текущего указателя перед переприсваиванием decrement_ref(); ptr_ = other.ptr_; ref_count_ = other.ref_count_; other.ptr_ = nullptr; other.ref_count_ = nullptr; } return *this; } // Деструктор ~SharedPointer() { decrement_ref(); } // Доступ к объекту T* operator->() const { return ptr_; } T& operator*() const { return *ptr_; } // Получение сырого указателя T* get() const { return ptr_; } // Получение количества ссылок long use_count() const { if (ref_count_) { return ref_count_->load(); } return 0; } // Проверка на нулевой указатель operator bool() const { return ptr_ != nullptr; } private: // Вспомогательная функция для уменьшения счетчика ссылок и очистки памяти void decrement_ref() { if (ref_count_) { // Атомарное уменьшение счетчика и проверка, стал ли он равным нулю if (--(*ref_count_) == 0) { delete ptr_; // Удаляем объект(ы) delete ref_count_; // Удаляем счетчик ptr_ = nullptr; ref_count_ = nullptr; } } } }; // Специализация для массива (для SharedPointer) template class SharedPointer { private: T* ptr_; // Сырой указатель на массив объектов std::atomic* ref_count_; // Указатель на счетчик ссылок (атомарный) public: // Конструктор, принимающий сырой указатель на массив explicit SharedPointer(T* ptr) : ptr_(ptr), ref_count_(new std::atomic(1)) {} // Конструктор копирования SharedPointer(const SharedPointer& other) : ptr_(other.ptr_), ref_count_(other.ref_count_) { if (ref_count_) { (*ref_count_)++; } } // Прочие конструкторы и операторы аналогичны SharedPointer для одного объекта, // но деструктор должен использовать `delete[]`. // Деструктор для массива ~SharedPointer() { if (ref_count_) { if (--(*ref_count_) == 0) { delete[] ptr_; // Удаляем массив объектов delete ref_count_; ptr_ = nullptr; ref_count_ = nullptr; } } } // Доступ к элементам массива T& operator[](size_t index) const { return ptr_[index]; } // Получение сырого указателя T* get() const { return ptr_; } // Получение количества ссылок long use_count() const { if (ref_count_) { return ref_count_->load(); } return 0; } // Проверка на нулевой указатель operator bool() const { return ptr_ != nullptr; } }; ``` Умные указатели для одного объекта (например, `UniquePointer`): * **Управление владением:** Указатель является исключительным владельцем объекта. * **Автоматическое удаление:** Объект автоматически удаляется при выходе указателя из области видимости или при переприсваивании. * **Нет подсчета ссылок:** overhead минимален. * **Неявная передача владения:** При перемещении ownership передается без копирования объекта. Умные указатели для одного или нескольких объектов с подсчетом ссылок (например, `SharedPointer`): * **Совместное владение:** Несколько указателей могут владеть одним и тем же объектом. * **Автоматическое удаление:** Объект удаляется только тогда, когда количество ссылок становится равным нулю. * **Использует счетчик ссылок:** overhead больше из-за управления счетчиком. * **Потокобезопасность (при использовании `std::atomic`):** Счетчик ссылок атомарный для безопасного использования в многопоточных приложениях. * **Возможность управления массивами:** Может быть специализирован для корректного удаления массивов (`delete[]`).

Как написать умный указатель для одного или нескольких объектов?