`std::unique_ptr::reset` în C++

reset șterge obiectul deținut (și poate prelua altul); release renunță la proprietate fără să șteargă.

Sintaxă

void reset(pointer p = nullptr) noexcept;
pointer release() noexcept;

Ce face `std::unique_ptr::reset`

p.reset() distruge imediat obiectul deținut și lasă pointerul gol. p.reset(new T(...)) distruge obiectul vechi și preia unul nou.

p.release() face opusul: nu șterge nimic. Returnează pointerul brut și lasă unique_ptr-ul gol; de acum tu răspunzi de delete. Se folosește rar, de obicei pentru a preda obiectul unui cod vechi care cere un pointer brut și preia el ștergerea.

Parametri

Parametru	Descriere
`p`	Pentru `reset`: noul pointer de deținut (implicit `nullptr`).

Ce returnează

reset nu returnează nimic. release returnează pointerul brut (T*) la obiectul care nu mai este deținut.

Exemple

Exemplul 1: reset: ștergere imediată

#include <memory>
#include <print>

struct Conexiune {
    int id;
    explicit Conexiune(int i) : id(i) { std::println("Conectare {}", id); }
    ~Conexiune() { std::println("Deconectare {}", id); }
};

int main() {
    auto c = std::make_unique<Conexiune>(1);
    c.reset(new Conexiune(2));   // 1 este șters, c deține acum 2
    c.reset();                   // 2 este șters, c devine gol
    std::println("c este gol: {}", !c);
}

Rezultat

Conectare 1
Conectare 2
Deconectare 1
Deconectare 2
c este gol: true

Exemplul 2: release: predai obiectul

După release, pointerul inteligent nu mai șterge nimic, așa că trebuie să apelezi tu delete.

#include <memory>
#include <print>

int main() {
    auto p = std::make_unique<int>(7);
    int* brut = p.release();

    std::println("p este gol: {}", p == nullptr);
    std::println("valoare: {}", *brut);
    delete brut;   // obligatoriu: nimeni altcineva nu îl mai șterge
}