Antes de comprender el concepto de la clase bad_weak_ptr, debemos saber qué son los punteros compartidos y los punteros débiles. Los punteros compartidos son aquellos en los que podemos copiar el puntero en diferentes variables. Podemos decir que los punteros compartidos han compartido la propiedad donde el puntero débil en sí no tiene ninguna propiedad: la propiedad de los punteros compartidos como referencia. El bad_weak_ptr es la clase incorporada que proporciona el estándar C++. Es el que se usa para lanzar el objeto como una excepción a través del constructor de los punteros compartidos y toma el puntero débil como argumento. El puntero débil en sí se refiere a un objeto eliminado.

Sintaxis:

A continuación se muestra la sintaxis para crear la excepción de clase bad_weak_ptr.

clase bad_weak_ptr: public std :: excepción
bad_weak_ptr ();
const char *what () throw ();
;

Esta clase define una excepción que podemos lanzar usando el constructor de punteros compartidos que está sosteniendo el argumento del tipo de puntero débil. En la sintaxis, la excepción anterior es el error que lanzaremos mientras ocurra el puntero mal débil. Dentro de la función de clase, declaramos dos funciones del tipo de datos de caracteres constante que son el método "What ()" y "Throw ()". La función "What ()" se usa para devolver el carácter terminado que identifica la excepción usada y el "Throw ()" se usa para lanzar la excepción cada vez que el compilador detecta el problema. El valor de retorno para el puntero de malos débiles es la cadena nula con la explicación.

Ejemplo # 01:

Ahora realicemos un ejemplo de bad_weak_ptr para verificar cómo funciona. El primer paso para realizarse en esto es incluir los archivos de encabezado "Iostrem" y la "memoria". El "iOStream" proporciona la capacidad de realizar operaciones de entrada-salida; mientras que la "memoria" nos permite realizar diversas operaciones relacionadas con la asignación de memoria, etc.

Ahora, en la función principal, declaramos un puntero compartido de tipo entero que tiene el nombre "PTR". A ese puntero, pasamos el valor entero "42" y usando la nueva palabra clave, la asignamos al montón de memoria. Y luego, usando el puntero débil, declaramos un bad_weak_ptr llamado "bad_weak_pointer" al que hizo referencia al puntero compartido "PTR". Ahora, utilizando la palabra clave RESET (), restableceremos los bits en el índice proporcionado de "PTR" a NULL o "0". A continuación, llamaremos a la instrucción Try que se usa para realizar algo definido por el usuario. Dentro de esto, hemos declarado otro puntero compartido llamado "P2" que mantendrá el puntero Bad Débil "Bad_weak_Pointer". Ahora, llamamos a la instrucción Catch () que nos permitirá definir el bloque de ejecución siempre que ocurra el error. A la instrucción Catch (), pasamos el bad_weak_ptr y el "err" como parámetro. El "ERR" se usa para contener el error que ocurrirá en este programa. Dentro de la variable "ERR" de los auxiliares rizados mostrará el tipo de error que ocurre en este código utilizando el método What (), que se utiliza para obtener la declaración que identifica el error.

#incluir
#incluir
int main ()

std :: shared_ptr ptr (nuevo int (42));
std :: débil_ptr bad_weak_pointer (PTR);
PTR.reiniciar();
intentar
std :: shared_ptr p2 (bad_weak_pointer);
catch (const std :: bad_weak_ptr & err)
std :: cout << err.what() << '\n';

Ahora, verifiquemos nuestra salida en la que se ha mostrado un error que ocurrió debido al mal puntero débil.

Ejemplo # 02:

En este ejemplo, intentaremos realizar otro programa bad_weak_ptr en el que crearemos un objeto de tipo de puntero compartido y llamaremos al constructor y al destructor. Tengamos una visión detallada del código que vamos a realizar. Después de incluir los mismos archivos de encabezado que hemos incluido en el ejemplo anterior. Crearemos un objeto "bd_ptr" usando estructura. Y llamado habilitado_shared_from_this para el objeto bd_ptr que permite el objeto bd_ptr que se administra por el puntero compartido llamado "bd_ptr".

Dentro de este objeto, llamaremos al constructor para el "bd_ptr" y el destructor. Además, dentro de estas ambas funciones, aprobamos la declaración que se mostrará en su ejecución exitosa. Y también creó una función para este objeto "bd-ptr" llamado "getBDPTR" que devolverá el shared_ptr que compartirá la propiedad de "esto". El método "shared_from_this ()" se usa para permitir el objeto que el puntero compartido está administrando, permite la creación de una instancia para el objeto del puntero compartido. Ahora, avanzando en nuestra función principal donde llamamos a la instrucción Try en la que declaramos una variable llamada "F" del objeto "BD_PTR" a la que asignamos un montón de memoria usando una "nueva" palabra clave.

También creamos un puntero compartido más de tipo "BD_PTR" llamado "SP" al que hemos asignado un método getBDPTR () señalando a través de la variable "F" del objeto tipo. Usando el operador "->", accedimos al elemento de la estructura para la variable "F". Al método de captura, pasamos un tipo constante bad_weak_ptr llamado "badweakptr", lo que significa que si se produce la excepción bad_weak_ptr, mostrará el código interno que hemos escrito dentro de los aparatos rizados en los que mostrará el nombre de la excepción que ocurre y al final, salimos del código con -1.

#incluir
#incluir
struct bd_ptr: public std :: enable_shared_from_this
bd_ptr () std :: cout << "bad pointer constructor\n";
~ bd_ptr () std :: cout << "bad pointer destructor\n";
std :: shared_ptr getBDPtr () return shared_from_this ();
;
int main ()

intentar

bd_ptr *f = nuevo bd_ptr;
std :: shared_ptr sp = f-> getBdptr ();

Catch (const std :: bad_weak_ptr y badweakptr)

std :: cout << badweakptr.what();
salida (-1);

regresar 0;

En el fragmento a continuación, hemos ejecutado con éxito el mensaje de creación del constructor, lo que significa que nuestro constructor se crea con éxito. Pero el destructor no se ejecuta porque hemos lanzado una excepción para el mal puntero débil. Entonces, mostró el código interno que hemos escrito dentro de la función de captura que mostró el tipo de error que ocurrió.

Conclusión

En esta guía, hemos estudiado la excepción que es BAD_WEAK_PTR que se utiliza para lanzar la excepción y devuelve el tipo de mensaje del error que ocurre en el momento de la ejecución. Realizamos diferentes ejemplos para explicar el concepto de esta excepción y cómo se usa en el código. Hicimos todo lo posible para explicar el funcionamiento del bad_weak_ptr.