Кратко — с примером и объяснениями.
1) unique_ptr — эксклюзивная (единоличная) владение
- Поведение: владелец единственный; копирование запрещено, можно перемещать (std::move). При выходе из области видимости ресурс автоматически удаляется (RAII).
- Решаемые проблемы: исключает утечки при обычном выходе/исключениях, нет неопределённого двойного удаления.
- Ограничение: не подходит, когда нужен совместный доступ нескольким владельцам.
Пример:
```
struct Foo { ~Foo(){ std::cout<<"~Foo\n"; } };
void f() {
std::unique_ptr p1 = std::make_unique();
std::unique_ptr p2 = std::move(p1); // p1 теперь nullptr
} // p2 уничтожается, вызывается ~Foo
```
2) shared_ptr — подсчёт ссылок (shared ownership)
- Поведение: объект хранится в совместном управлении; у каждого shared_ptr есть общий контрольный блок с сильным (strong) счётчиком владений. Когда сильный счётчик достигает нуля — объект удаляется.
- Решаемые проблемы: удобно для разделяемых ресурсов, автоматическое освобождение когда последний владелец исчезает.
- Важная деталь: shared_ptr хранит контрольный блок; операция copy/assign атомарна по счётчику в многопоточном окружении.
Пример:
```
struct Foo { ~Foo(){ std::cout<<"~Foo\n"; } };
void g() {
auto a = std::make_shared();
auto b = a; // увеличивается счётчик владения
std::cout << a.use_count(); // например $2$ } // при выходе из g() ~Foo вызывается, когда счётчик станет $0$ ```
3) Циклические ссылки (проблема для shared_ptr)
- Сценарий: два объекта держат shared_ptr друг на друга. Тогда сильные счётчики никогда не дойдут до нуля, потому что каждый удерживает другой, объект не освобождается — утечка памяти.
Пример утечки:
```
struct B;
struct A { std::shared_ptr pb; ~A(){ std::cout<<"~A\n"; } };
struct B { std::shared_ptr pa; ~B(){ std::cout<<"~B\n"; } };
int main() {
auto a = std::make_shared();
auto b = std::make_shared();
a->pb = b;
b->pa = a;
} // ни ~A, ни ~B не вызовутся — leak (сильные счётчики не становятся $0$)
```
Решение: weak_ptr — слабая ссылка, не увеличивает сильный счётчик
- weak_ptr не владеет объектом, хранит «слабый» счётчик в контрольном блоке; позволяет безопасно проверить и получить shared_ptr через lock().
- Использование: один из связей в цикле делаем weak_ptr, тогда при удалении последних shared_ptr объект будет уничтожен.
Исправление примера:
```
struct B;
struct A { std::shared_ptr pb; ~A(){ std::cout<<"~A\n"; } };
struct B { std::weak_ptr pa; ~B(){ std::cout<<"~B\n"; } };
int main() {
auto a = std::make_shared();
auto b = std::make_shared();
a->pb = b;
b->pa = a; // не увеличивает сильный счётчик
} // ~A и ~B будут вызваны корректно
```
При доступе:
```
if (auto s = b->pa.lock()) { /* используем s (shared_ptr) */ }
```
Краткие дополнительные замечания
- unique_ptr по своей природе не даёт циклов сильного владения, но циклы могут появиться, если один из объектов хранит сырые (raw) или слабые указатели в обратном направлении.
- shared_ptr + weak_ptr — стандартный способ разрывать циклы; weak_ptr хранит только ссылку на контрольный блок, объект остаётся до тех пор, пока есть сильные владельцы.
- В многопоточном окружении операции над shared_ptr атомарны для счётчика, но логика владения всё равно требует осторожности.
Вывод: unique_ptr — для единоличного владения; shared_ptr — для совместного владения, но может привести к утечкам при циклических ссылках; предотвращаются заменой одной стороны цикла на weak_ptr.