std::shared_ptr<T>::reset
De cppreference.com
< 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 con un objeto al que apunta ptr. Se puede proporcionar el eliminador opcional d, que luego se usa para destruir el nuevo objeto cuando ningún objeto shared_ptr lo posee. Por defecto, la expresión delete se usa como eliminador. Siempre se selecciona la expresión adecuada delete correspondiente al tipo proporcionado, 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 a través del eliminador almacenado.
Si el objeto al que apunta ptr ya se posee, la función generalmente da como resultado un comportamiento no definido.
1) Libera la posesión del objeto gestionado, si la hubiere. 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. Además:2) Utiliza la expresión
delete como eliminador. Debe estar disponible una expresión válida delete, 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 eliminador especificado
d como eliminador. Deleter debe poder llamarse para el tipo T, es decir, d(ptr) debe estar bien formado, tener un comportamiento bien definido y no lanzar ninguna excepción. 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 además usa 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);.Contenido |
[editar] Parámetros
| ptr | - | Puntero a un objeto del que adquirir la posesión. |
| d | - | Eliminador a almacenar para la eliminación del objeto. |
| alloc | - | Asignador de memoria a usar para las asignaciones de memoria internas. |
[editar] Valor de retorno
(Ninguno)
[editar] Excepciones
2) std::bad_alloc si no se pudo obtener la memoria adicional necesaria. Puede lanzar una excepción definida por la implementación para otros errores. Se llama a delete ptr si ocurre una excepción.
3-4) std::bad_alloc si no se pudo obtener la memoria adicional necesaria. Puede lanzar una excepción definida por la implementación para otros errores. Se llama a d(ptr) si ocurre una excepción.
[editar] Ejemplo
Ejecuta este código
#include <memory> #include <iostream> 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'; // Restablecer el shared_ptr sin darle una nueva instancia de Foo. // La instancia anterior se destruirá después de esta llamada. std::cout << "llamar a sptr.reset()...\n"; sptr.reset(); // aquí se llama al destructor de Foo std::cout << "después de llamar a reset(): use_count() = " << sptr.use_count() << ", sptr = " << sptr << '\n'; } // No se llama al destructor de Foo, se hizo antes 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'; // Restablecer el shared_ptr dándole una nueva instancia de Foo. // La instancia anterior se destruirá después de esta llamada. std::cout << "llamar a sptr.reset()...\n"; sptr.reset(new Foo{222}); std::cout << "después de llamar a reset(): use_count() = " << sptr.use_count() << ", sptr = " << sptr << "\nsaliendo de ámbito...\n"; } // Se 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'; // Restablecer el shared_ptr sptr1, dándole una nueva instancia de Foo. // La instancia anterior quedará compartida entre sptr2 y sptr3. std::cout << "llamar a sptr1.reset()...\n"; sptr1.reset(new Foo{333}); std::cout << "después de llamar a 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 de ámbito...\n"; } // Llama a dos destructores de: 1) Foo poseído por sptr1, // 2) Foo compartido entre sptr2/sptr3. }
Posible salida:
1) Propiedad única Foo::Foo(), bar = 100 @ 0x23c5040 Foo::bar = 100, use_count() = 1 llamar a sptr.reset()... Foo::~Foo(), bar = 100 @ 0x23c5040 después de llamar a reset(): use_count() = 0, sptr = 0 2) Propiedad única Foo::Foo(), bar = 200 @ 0x23c5040 Foo::bar = 200, use_count() = 1 llamar a sptr.reset()... Foo::Foo(), bar = 222 @ 0x23c5050 Foo::~Foo(), bar = 200 @ 0x23c5040 después de llamar a reset(): use_count() = 1, sptr = 0x23c5050 saliendo de ámbito... Foo::~Foo(), bar = 222 @ 0x23c5050 3) Propiedad múltiple Foo::Foo(), bar = 300 @ 0x23c5080 Foo::bar = 300, use_count() = 3 llamar a sptr1.reset()... Foo::Foo(), bar = 333 @ 0x23c5050 después de llamar a reset(): sptr1.use_count() = 1, sptr1 @ 0x23c5050 sptr2.use_count() = 2, sptr2 @ 0x23c5080 sptr3.use_count() = 2, sptr3 @ 0x23c5080 saliendo de ámbito... Foo::~Foo(), bar = 300 @ 0x23c5080 Foo::~Foo(), bar = 333 @ 0x23åc5050
[editar] Véase también
Construye un nuevo shared_ptr. (función miembro pública) |
