std::shared_ptr<T>:: reset
From cppreference.net
<
cpp
|
memory
|
shared ptr
|
void
reset
(
)
noexcept
;
|
(1) | (desde C++11) |
|
template
<
class
Y
>
void reset ( Y * ptr ) ; |
(2) | (desde C++11) |
|
template
<
class
Y,
class
Deleter
>
void reset ( Y * ptr, Deleter d ) ; |
(3) | (desde C++11) |
|
template
<
class
Y,
class
Deleter,
class
Alloc
>
void reset ( Y * ptr, Deleter d, Alloc alloc ) ; |
(4) | (desde C++11) |
Reemplaza el objeto gestionado por un objeto apuntado por
ptr
. Se puede proporcionar un deleter opcional
d
, que posteriormente se utiliza para destruir el nuevo objeto cuando ningún objeto
shared_ptr
lo posee. Por defecto, se utiliza la expresión
delete
como deleter. Siempre se selecciona la expresión
delete
apropiada correspondiente al tipo suministrado, esta es la razón por la cual la función se implementa como plantilla usando un parámetro separado
Y
.
Si
*
this
ya posee un objeto y es el último
shared_ptr
que lo posee, el objeto se destruye mediante el deleter asociado.
Si el objeto apuntado por ptr ya está en posesión, la función generalmente resulta en comportamiento indefinido.
1)
Libera la propiedad del objeto gestionado, si existe. Después de la llamada,
*
this
no gestiona ningún objeto. Equivalente a
shared_ptr
(
)
.
swap
(
*
this
)
;
.
2-4)
Reemplaza el objeto gestionado con un objeto apuntado por
ptr
.
Y
debe ser un tipo completo e implícitamente convertible a
T
. Adicionalmente:
2)
Utiliza la expresión delete como el deleter. Debe estar disponible una expresión delete válida, es decir,
delete ptr
debe estar bien formada, tener un comportamiento bien definido y no lanzar ninguna excepción. Equivalente a
shared_ptr
<
T
>
(
ptr
)
.
swap
(
*
this
)
;
.
3)
Utiliza el deleter especificado
d
como el deleter.
Deleter
debe ser invocable para el tipo
T
, es decir,
d
(
ptr
)
debe estar bien formado, tener un comportamiento bien definido y no lanzar excepciones.
Deleter
debe ser
CopyConstructible
, y su constructor de copia y destructor no deben lanzar excepciones. Equivalente a
shared_ptr
<
T
>
(
ptr, d
)
.
swap
(
*
this
)
;
.
4)
Igual que
(3)
, pero adicionalmente utiliza una copia de
alloc
para la asignación de datos para uso interno.
Alloc
debe ser un
Allocator
. El constructor de copia y el destructor no deben lanzar excepciones. Equivalente a
shared_ptr
<
T
>
(
ptr, d, alloc
)
.
swap
(
*
this
)
;
.
Contenidos |
Parámetros
| ptr | - | puntero a un objeto para adquirir la propiedad |
| d | - | deleter a almacenar para la eliminación del objeto |
| alloc | - | asignador a utilizar para asignaciones internas |
Valor de retorno
(ninguno)
Excepciones
2)
std::bad_alloc
si no se pudo obtener la memoria adicional requerida. Puede lanzar excepciones definidas por la implementación para otros errores.
delete ptr
se llama si ocurre una excepción.
3,4)
std::bad_alloc
si no se pudo obtener la memoria adicional requerida. Puede lanzar excepciones definidas por la implementación para otros errores.
d
(
ptr
)
se llama si ocurre una excepción.
Ejemplo
Ejecutar este código
#include <iostream> #include <memory> struct Foo { Foo(int n = 0) noexcept : bar(n) { std::cout << "Foo::Foo(), bar = " << bar << " @ " << this << '\n'; } ~Foo() { std::cout << "Foo::~Foo(), bar = " << bar << " @ " << this << '\n'; } int getBar() const noexcept { return bar; } private: int bar; }; int main() { std::cout << "1) propiedad única\n"; { std::shared_ptr<Foo> sptr = std::make_shared<Foo>(100); std::cout << "Foo::bar = " << sptr->getBar() << ", use_count() = " << sptr.use_count() << '\n'; // Reiniciar el shared_ptr sin asignarle una nueva instancia de Foo. // La instancia anterior será destruida después de esta llamada. std::cout << "llamar a sptr.reset()...\n"; sptr.reset(); // llama al destructor de Foo aquí std::cout << "Después de reset(): use_count() = " << sptr.use_count() << ", sptr = " << sptr << '\n'; } // No se llama al destructor de Foo, se realizó anteriormente en reset(). std::cout << "\n2) propiedad única\n"; { std::shared_ptr<Foo> sptr = std::make_shared<Foo>(200); std::cout << "Foo::bar = " << sptr->getBar() << ", use_count() = " << sptr.use_count() << '\n'; // Reiniciar el shared_ptr, asignarle una nueva instancia de Foo. // La instancia anterior será destruida después de esta llamada. std::cout << "llamar a sptr.reset()...\n"; sptr.reset(new Foo{222}); std::cout << "Después de reset(): use_count() = " << sptr.use_count() << ", sptr = " << sptr << "\nSaliendo del ámbito...\n"; } // Llama al destructor de Foo. std::cout << "\n3) propiedad múltiple\n"; { std::shared_ptr<Foo> sptr1 = std::make_shared<Foo>(300); std::shared_ptr<Foo> sptr2 = sptr1; std::shared_ptr<Foo> sptr3 = sptr2; std::cout << "Foo::bar = " << sptr1->getBar() << ", use_count() = " << sptr1.use_count() << '\n'; // Reinicializar el shared_ptr sptr1, asignándole una nueva instancia de Foo. // La instancia antigua permanecerá compartida entre sptr2 y sptr3. std::cout << "llamar a sptr1.reset()...\n"; sptr1.reset(new Foo{333}); std::cout << "Después de reset():\n" << "sptr1.use_count() = " << sptr1.use_count() << ", sptr1 @ " << sptr1 << '\n' << "sptr2.use_count() = " << sptr2.use_count() << ", sptr2 @ " << sptr2 << '\n' << "sptr3.use_count() = " << sptr3.use_count() << ", sptr3 @ " << sptr3 << '\n' << "Saliendo del ámbito...\n"; } // Llama a dos destructores de: 1) Foo propiedad de sptr1, // 2) Foo compartido entre sptr2/sptr3. }
Salida posible:
1) propiedad única Foo::Foo(), bar = 100 @ 0x23c5040 Foo::bar = 100, use_count() = 1 llamando a sptr.reset()... Foo::~Foo(), bar = 100 @ 0x23c5040 Después de reset(): use_count() = 0, sptr = 0 2) propiedad única Foo::Foo(), bar = 200 @ 0x23c5040 Foo::bar = 200, use_count() = 1 llamando a sptr.reset()... Foo::Foo(), bar = 222 @ 0x23c5050 Foo::~Foo(), bar = 200 @ 0x23c5040 Después de reset(): use_count() = 1, sptr = 0x23c5050 Saliendo del ámbito... Foo::~Foo(), bar = 222 @ 0x23c5050 3) propiedad múltiple Foo::Foo(), bar = 300 @ 0x23c5080 Foo::bar = 300, use_count() = 3 llamando a sptr1.reset()... Foo::Foo(), bar = 333 @ 0x23c5050 Después de reset(): sptr1.use_count() = 1, sptr1 @ 0x23c5050 sptr2.use_count() = 2, sptr2 @ 0x23c5080 sptr3.use_count() = 2, sptr3 @ 0x23c5080 Saliendo del ámbito... Foo::~Foo(), bar = 300 @ 0x23c5080 Foo::~Foo(), bar = 333 @ 0x23c5050
Véase también
construye un nuevo
shared_ptr
(función miembro pública) |