C ++ std débe_ptr

El requisito previo para estudiar el puntero débil es que debemos saber sobre los punteros únicos y los punteros compartidos. Un puntero único tiene una propiedad única. Sostiene los objetos administrados y no permite que nadie maneje esos objetos. Supongamos que tenemos un objeto llamado "P" que es administrado por un puntero único. Entonces, no podemos copiar este puntero. En el otro caso, para el puntero compartido, también tenemos "P" pero estamos usando un puntero compartido. Esta vez, puede copiar este puntero compartido en varias variables diferentes y utilizaremos un recuento de referencias para contar cuántos punteros inteligentes están utilizando o señalando este objeto administrado en particular.

Ahora, podemos decir que el puntero único es para una propiedad única. El puntero compartido es para la propiedad compartida. Y el puntero débil es para la falta de propiedad. Un puntero débil también es un puntero inteligente; no participará en la propiedad en absoluto. Es una referencia a un objeto administrado por un puntero compartido. Ahora, una cosa que puede estar atascada en nuestra mente es que si el puntero débil no tiene ninguna propiedad como un puntero único o compartido, ¿cómo se manejará este puntero débil?? El puntero no tiene nada con él, toma el objeto administrado de los punteros compartidos. Se utilizan para romper la dependencia circular de los compartidos.

Sintaxis:

La sintaxis para aplicar un puntero débil en el programa es la siguiente:

std :: débil_ptr p (nuevo int);

En la sintaxis dada, el tipo es el tipo de datos que controla el puntero débil.

Ejemplo 1:

Para comprender el puntero débil de una mejor manera, primero damos un ejemplo para que sea más fácil para nosotros entender cómo funciona. En este ejemplo, creamos un puntero débil usando los punteros compartidos y creamos el número de referencias utilizando el puntero débil. Como discutimos anteriormente, el puntero débil en sí no tiene propiedad; Se necesita la propiedad de otros punteros para romper una dependencia circular de los objetos. Ahora, avanzando hacia nuestro código donde primero incluimos dos archivos de encabezado: el primer archivo de encabezado es la "memoria" y el segundo archivo de encabezado es el "iostream". El "iOStream" se usa para permitir que el codificador realice las operaciones de E/S, mientras que la "memoria" es la biblioteca que se usa para administrar la memoria dinámica.

A continuación, pasamos a la función principal donde definimos un puntero compartido del tipo entero y nombra el puntero "shr_ptr_a". Usando el "nuevo" operador, asignamos la memoria en el montón de int "12". Ahora, declaramos un puntero débil del tipo entero y lo nombramos como "wk_ptr" al que pasamos el puntero compartido. Esto significa que contiene la referencia del entero "12". Después de declararlo con éxito, imprimimos el número de recuentos de que el puntero débil se llama usando el "Use_count ()" que se utiliza para devolver el número de instancias de puntero compartidas que administra el objeto actual. En este ejemplo, realizamos este paso 3 veces creando los tres objetos compartidos. Al final del código, devolvemos los valores nulos.

#incluir
#incluir
int main ()

std :: shared_ptr shr_ptr_a (nuevo int (12));
std :: débil_ptr wk_ptr (shr_ptr_a);
std :: cout << "Total Number of weak pointers : "
<< wk_ptr.use_count() << std::endl;
std :: shared_ptr shr_ptr_b (shr_ptr_a);
std :: cout << "Total Number of weak pointers : "
<< wk_ptr.use_count() << std::endl;
std :: shared_ptr shr_ptr_c (shr_ptr_a);
std :: cout << "Total Number of weak pointers : "
<< wk_ptr.use_count() << std::endl;
return (0);

Ahora, verifiquemos la salida del código que se muestra en el siguiente fragmento en el que imprimimos el número de referencias que se crean. Después de la creación de cada referencia, imprimimos el recuento para eso. Para la primera salida fue una, para la segunda salida fue 2, y para la última salida fue 3. Esto significa que el total de tres referencias se crean utilizando el puntero débil.

Ejemplo 2:

Realizamos otro ejemplo en el que creamos dos clases y las destruimos usando el puntero débil. Cada vez que accedemos a cualquier objeto o lo eliminamos en cualquier momento por cualquier puntero inteligente, se usa un puntero débil para rastrear eso. Se convierte en un puntero compartido como propiedad temporal. Si queremos destruir el puntero compartido original, la vida útil para el objeto se extiende hasta que destruyamos el puntero compartido temporal.

Ahora, procedamos al código donde primero incluimos los archivos de encabezado. Antes de sumergirnos en la función principal, declaramos dos clases: la primera es la "class_a" y la segunda es el "class_b". Dentro del "class_a", primero definimos un puntero débil llamado "BPTR" al pasar el "class_b" como parámetro. Luego, llamamos a un constructor y un destructor de "class_a". Repetimos los mismos pasos para el "class_b" en el que definimos un puntero débil y pasamos un "class_a" como parámetro. El constructor muestra un mensaje de creación de la clase. Cuando se llama a la función de destrucción, muestra el mensaje destruido de la clase.

Después de eso, salimos a la función principal donde declaramos los consejos compartidos que nombran "A" y "B" a los que asignamos una función "Make_Shared" donde pasamos ambas clases como parámetro. La función "make_shared" se usa para asignar y crear cualquier tipo de objeto al pasar el tipo de datos como argumento. Devuelve el objeto del puntero compartido que es el propietario del objeto y lo almacena. Por último, utilizando los punteros compartidos "A" y "B", los indexamos para acceder al índice de memoria detrás de las ubicaciones indicadas por "BPTR" y "APTR". Esto significa que asignamos los objetos de punteros compartidos al puntero débil.

#incluir
#incluir
class class_b;
clase class_a

público:
std :: débil_ptrBPTR;
clase A()
std :: cout << "class_a created sucessfully" << std::endl;

~ class_a ()
std :: cout << "class_a destroyed sucessfully" << std::endl;

;
clase class_b

público:
std :: débil_ptraptr;
clase B()
std :: cout << "class_b created sucessfull" << std::endl;

~ class_b ()
std :: cout << "class_b destroyed sucessfully" b-> aptr = a;

En el siguiente fragmento, la salida de nuestro código se muestra donde podemos verificar que ambos class_and class_b se creen y destruyan con éxito.

Conclusión

En este artículo, estudiamos el uso de punteros débiles, cómo funcionan y el propósito de usar los punteros débiles utilizando múltiples ejemplos que incluyen el código y la salida. Los punteros débiles juegan un papel vital en c++. En coordinación con los punteros compartidos, los punteros débiles ayudan mientras declaran o inicializan un ciclo optimizado para obtener los elementos. También ayudan en la adquisición de recursos.