Namespaces
Variants

std::unique_ptr<T,Deleter>:: reset

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
std::unique_ptr
miembros de la plantilla principal, unique_ptr<T>
void reset ( pointer ptr = pointer ( ) ) noexcept ;
(1) (constexpr desde C++23)
miembros de la especialización unique_ptr<T[]>
template < class U >
void reset ( U ptr ) noexcept ;
(2) (constexpr desde C++23)
void reset ( std:: nullptr_t = nullptr ) noexcept ;
(3) (constexpr desde C++23)

Reemplaza el objeto administrado.

1,2) Equivalente a auto old_ptr = get ( ) ;
/* assigns “ptr” to the stored pointer */
if ( old_ptr )
get_deleter ( ) ( old_ptr ) ; .
Si get_deleter ( ) ( old_ptr ) lanza una excepción, el comportamiento es indefinido.
2) Esta sobrecarga participa en la resolución de sobrecarga solo si U es del mismo tipo que pointer , o se cumplen todas las siguientes condiciones:
  • pointer es del mismo tipo que element_type* .
  • U es un tipo puntero V* tal que V(*)[] es convertible a element_type(*)[] .
3) Equivalente a reset ( pointer ( ) ) .

Contenidos

Parámetros

ptr - puntero a un nuevo objeto a gestionar

Notas

Para reemplazar el objeto gestionado proporcionando también un nuevo eliminador, se puede utilizar el operador de asignación de movimiento.

Una prueba para auto-reseteo, es decir, si ptr apunta a un objeto ya gestionado por * this , no se realiza, excepto cuando se proporciona como una extensión del compilador o como un assert de depuración. Nótese que código como p. reset ( p. release ( ) ) no involucra auto-reseteo, solo código como p. reset ( p. get ( ) ) lo hace.

Ejemplo

Ejecutar este código 
#include <iostream>
#include <memory>
struct Foo // object to manage
{
    Foo() { std::cout << "Foo...\n"; }
    ~Foo() { std::cout << "~Foo...\n"; }
};
struct D // deleter
{
    void operator() (Foo* p)
    {
        std::cout << "Calling delete for Foo object... \n";
        delete p;
    }
};
int main()
{
    std::cout << "Creating new Foo...\n";
    std::unique_ptr<Foo, D> up(new Foo(), D()); // up owns the Foo pointer (deleter D)
    std::cout << "Replace owned Foo with a new Foo...\n";
    up.reset(new Foo());  // calls deleter for the old one
    std::cout << "Release and delete the owned Foo...\n";
    up.reset(nullptr);      
}

Salida: 

Creating new Foo...
Foo...
Replace owned Foo with a new Foo...
Foo...
Calling delete for Foo object...
~Foo...
Release and delete the owned Foo...
Calling delete for Foo object...
~Foo...

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 2118 C++11 unique_ptr<T[]>::reset rechazaba conversiones de calificación acepta
LWG 2169 C++11 la sobrecarga unique_ptr<T[]>::reset(pointer) existía eliminó la sobrecarga

Véase también

devuelve un puntero al objeto gestionado y libera la propiedad
(función miembro pública)