X Tutup
The Wayback Machine - https://web.archive.org/web/20220416164253/https://es.cppreference.com/w/cpp/memory/weak_ptr
Espacios de nombres
Variantes
Acciones

std::weak_ptr

De cppreference.com
< cpp‎ | memory
 
C++
 
Biblioteca de utilerías
Soporte de tipos (tipos básicos, RTTI, rasgos de tipo)
Administración de memoria dinámica
Control de errores
Utilidades de programas
Funciones variádicas
Biblioteca de macros para prueba de características
Fecha y hora
Objetos función
Biblioteca de formato (C++20)
(C++11)
(C++20)
(C++11)
(C++14)
Operadores relacionales (en desuso en C++20)
Comparaciones (C++20)
Tipos de vocabulario comunes
(C++11)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)

Intercambio, reenvío y movimiento
(C++14)
(C++11)
(C++11)
(C++11)
Conversiones elementales de cadenas
(C++17)
(C++17)
(C++17)
Operaciones de tipos
(C++11)
(C++17)
(C++17)
 
Gestión de memoria dinámica
Punteros inteligentes
(C++11)
(C++11)
weak_ptr
(C++11)
(hasta C++17)
(C++11)
(C++11)
(C++11)
(C++11)
(C++23)
(C++23)
Asignadores de memoria
(C++11)
(C++23)
(C++23)
(C++11)
(C++11)
(C++11)
(C++20)
(C++20)
(C++20)
(C++11)
(C++17)
Recursos de memoria
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
Almacenamiento no inicializado
(hasta C++20)
(hasta C++20)
(hasta C++20)
Algoritmos de memoria no inicializada
Algoritmos restringidos de memoria no inicializada
Apoyo para recolección de basura
(C++11)(hasta C++23)
(C++11)(hasta C++23)
(C++11)(hasta C++23)
(C++11)(hasta C++23)
(C++11)(hasta C++23)
(C++11)(hasta C++23)
Misceláneos
(C++11)
(C++20)
(C++11)
(C++11)
(C++20)
 
std::weak_ptr
 
Definido en el archivo de encabezado <memory>
template< class T > class weak_ptr;
 (desde C++11)

std::weak_ptr es un puntero inteligente que contiene una referencia de no propiedad ("débil") a un objeto que es gestionado por std::shared_ptr. Debe convertirse a std::shared_ptr para poder acceder al objeto referenciado.

std::weak_ptr modela la posesión temporal: cuando un objeto necesita ser accedido solo si existe, y puede ser eliminado en cualquier momento por alguien más, se usa std::weak_ptr para rastrear el objeto, y se convierte a std::shared_ptr para asumir la posesión temporal. Si el std::shared_ptr original se destruye en este momento, el tiempo de vida del objeto se extiende hasta que el std::shared_ptr temporal también se destruya.

Otro uso para std::weak_ptr es romper ciclos de referencia formados por objetos gestionados por std::shared_ptr. Si dicho ciclo queda huérfano (es decir, no hay punteros externos compartidos en el ciclo), los conteos de referencia de shared_ptr no pueden llegar a cero y se genera una fuga de memoria. Para evitar esto, uno de los punteros del ciclo se puede hacer débil.

Contenido

[editar] Tipos miembro

Tipo miembro Definición
element_type

T

(hasta C++17)

std::remove_extent_t<T>

(desde C++17)

[editar] Funciones miembro

 Crea un nuevo weak_ptr.
(función miembro pública) [editar]
Destruye un weak_ptr.
(función miembro pública) [editar]
Asigna el weak_ptr.
(función miembro pública) [editar]
Modificadores
Libera la posesión del objeto gestionado.
(función miembro pública) [editar]
Intercambia los objetos gestionados.
(función miembro pública) [editar]
Observadores
Devuelve el número de objetos shared_ptr que gestionan el objeto.
(función miembro pública) [editar]
Comprueba si el objeto referenciado ya ha sido eliminado.
(función miembro pública) [editar]
Crea un shared_ptr que gestiona el objeto referenciado.
(función miembro pública) [editar]
Proporciona ordenamiento de punteros débiles basado en propietario.
(función miembro pública) [editar]

[editar] Funciones no miembro

(C++11)
 Especializa el algoritmo std::swap.
(plantilla de función) [editar]

[editar] Clases auxiliares

(C++20)
 Puntero débil atómico.
(especialización de plantilla de clase) [editar]

[editar] Guías de deducción (desde C++17)

[editar] Notas

Al igual que std::shared_ptr, una implementación típica de weak_ptr almacena dos punteros:

  • un puntero al bloque de control; y
  • el puntero almacenado del shared_ptr a partir del cual se construyó.

Es necesario un puntero almacenado por separado para garantizar que la conversión de un shared_ptr a weak_ptr y luego de regreso funcione correctamente, incluso para shared_ptrs con alias. No es posible acceder al puntero almacenado en un weak_ptr sin bloquearlo en un shared_ptr.

[editar] Ejemplo

Demuestra cómo se usa el bloqueo para garantizar la validez del puntero.

Ejecuta este código
#include <iostream>
#include <memory>
 
std::weak_ptr<int> gw;
 
void observe()
{
    std::cout << "gw.use_count() == " << gw.use_count() << "; ";
    // tenemos que hacer una copia del puntero compartido antes de su uso:
    if (std::shared_ptr<int> spt = gw.lock()) {
        std::cout << "*spt == " << *spt << '\n';
    }
    else {
        std::cout << "gw ha expirado\n";
    }
}
 
int main()
{
    {
        auto sp = std::make_shared<int>(42);
        gw = sp;
 
        observe();
    }
 
    observe();
}

Salida: 

gw.use_count() == 1; *spt == 42
gw.use_count() == 0; gw ha expirado

[editar] Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID Aplicado a Comportamiento según lo publicado Comportamiento correcto
LWG 3001 C++17 element_type no se actualizaba para apoyo de arrays. Se actualizó.

[editar] Véase también

(C++11)
 Puntero inteligente con semántica de propiedad de objeto única.
(plantilla de clase) [editar]
(C++11)
 Puntero inteligente con semántica de propiedad de objeto compartida.
(plantilla de clase) [editar]
Obtenido de «https://es.cppreference.com/mwiki/index.php?title=cpp/memory/weak_ptr&oldid=41688»
X Tutup