Avant de comprendre le concept de la classe bad_weak_ptr, nous devons savoir ce que sont les pointeurs et les pointeurs faibles partagés. Les pointeurs partagés sont ceux dans lesquels nous pouvons copier le pointeur dans différentes variables. Nous pouvons dire que les pointeurs partagés ont partagé la propriété où le pointeur faible lui-même n'a pas de propriété: il prend la propriété des pointeurs partagés comme référence. Le bad_weak_ptr est la classe intégrée qui est fournie par la norme C++. C'est celui qui est utilisé pour lancer l'objet comme exception à travers le constructeur des pointeurs partagés et il faut le pointeur faible comme argument. Le pointeur faible se réfère à un objet supprimé.

Syntaxe:

Ci-dessous est la syntaxe pour créer l'exception de la classe bad_weak_ptr.

Classe BAD_WEAK_PTR: Exception publique STD ::
bad_weak_ptr ();
const char * what () throw ();
;

Cette classe définit une exception que nous pouvons lancer en utilisant le constructeur de pointeurs partagés qui tient l'argument du type du pointeur faible. Dans la syntaxe, l'exception ci-dessus est l'erreur que nous lancerons pendant que le mauvais pointeur faible se produit. À l'intérieur de la fonction de classe, nous avons déclaré deux fonctions de type de données de caractère constant qui sont la méthode «quoi ()» et la méthode «throw ()». La fonction «quoi ()» est utilisée pour retourner le caractère terminé qui identifie l'exception utilisée et le «throw ()» est utilisé pour lancer l'exception chaque fois que le compilateur détecte le problème. La valeur de retour pour le mauvais pointeur faible est la chaîne à terminaison nulle avec l'explication.

Exemple # 01:

Laissez maintenant un exemple de bad_weak_ptr pour vérifier comment cela fonctionne. La première étape pour être effectuée dans ce domaine consiste à inclure les fichiers d'en-tête «iostrem» et la «mémoire». Le «iOStream» offre la possibilité d'effectuer des opérations d'entrée-sortie; tandis que la «mémoire» nous permet d'effectuer diverses opérations liées à l'allocation de la mémoire, etc.

Maintenant, dans la fonction principale, nous avons déclaré un pointeur partagé de type entier ayant le nom «PTR». À ce pointeur, nous avons passé la valeur entière «42» et en utilisant le nouveau mot-clé, nous l'avons alloué au tas de mémoire. Et puis, en utilisant le pointeur faible, nous avons déclaré un bad_weak_ptr nommé «bad_weak_pointer» auquel nous avons référencé le pointeur partagé «PTR». Maintenant, en utilisant le mot-clé reset (), nous réinitialiserons les bits sur l'indice fourni de "PTR" à Null ou "0". Ensuite, nous appellerons l'instruction Try qui est utilisée pour effectuer quelque chose défini par l'utilisateur. À l'intérieur, nous avons déclaré un autre pointeur partagé nommé "P2" qui tiendra le mauvais pointeur faible "bad_weak_pointer". Maintenant, nous appelons l'instruction Catch () qui nous permettra de définir le bloc d'exécution chaque fois que l'erreur se produit. À l'instruction Catch (), nous avons passé le bad_weak_ptr et le «err» en tant que paramètre. Le «err» est utilisé pour maintenir l'erreur qui se produira dans ce programme. À l'intérieur de la variable «err», affichera le type d'erreur qui se produit dans ce code en utilisant la méthode What (), qui est utilisée pour obtenir l'instruction qui identifie l'erreur.

#inclure
#inclure
int main()

std :: shared_ptr ptr (new int (42));
std :: faible_ptr bad_weak_pointer (ptr);
ptr.réinitialiser();
essayer
std :: shared_ptr p2 (bad_weak_pointer);
catch (const std :: bad_weak_ptr & err)
std :: cout << err.what() << '\n';

Maintenant, vérifions notre sortie dans laquelle une erreur a été affichée qui s'est produite en raison du mauvais pointeur faible.

Exemple # 02:

Dans cet exemple, nous essaierons d'effectuer un autre programme BAD_WEAK_PTR dans lequel nous créerons un objet de type de pointeur partagé et appeler le constructeur et le destructeur. Ayons une vue détaillée du code que nous allons effectuer. Après avoir inclus les mêmes fichiers d'en-tête que nous avons inclus dans l'exemple ci-dessus. Nous allons créer un objet «BD_PTR» en utilisant la structure. Et appelé actived_shared_from_this pour l'objet BD_PTR qui permet à l'objet BD_PTR qui est géré par le pointeur partagé nommé "BD_PTR".

À l'intérieur de cet objet, nous appellerons le constructeur du «BD_PTR» et du destructeur. De plus, à l'intérieur de ces deux fonctions, nous passons la déclaration qui sera affichée sur leur exécution réussie. Et a également créé une fonction pour cet objet "BD-PTR" nommé "GetBDPTR" qui renverra le partage_ptr qui partagera la propriété de "ceci". La méthode «Shared_From_This ()» est utilisée pour permettre à l'objet que le pointeur partagé gére, il permet la création d'une instance pour l'objet du pointeur partagé. Maintenant, passant à notre fonction principale où nous avons appelé l'instruction Try dans laquelle nous avons déclaré une variable nommée «F» de l'objet «bd_ptr» auquel nous avons attribué un tas de mémoire à l'aide d'un «nouveau» mot-clé.

Nous avons également créé un plus pointeur partagé de type «BD_PTR» nommé «SP» auquel nous avons attribué une méthode getbdptr () en pointant via la variable «F» de l'objet type. À l'aide de l'opérateur «->», nous avons accédé à l'élément de la structure pour la variable «F». À la méthode Catch, nous avons passé un type constant bad_weak_ptr nommé «badweakptr», ce qui signifie que si l'exception BAD_weak_ptr se produit, elle affichera le code intérieur que nous avons écrit à l'intérieur des accolades bouclées dans lesquelles il affichera le nom de l'exception qui se produit qui se produit Et à la fin, nous quittons le code avec -1.

#inclure
#inclure
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()

essayer

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

Catch (const std :: bad_weak_ptr & badweakptr)

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

retour 0;

Dans l'extrait ci-dessous, nous avons exécuté avec succès le message de création du constructeur qui signifie que notre constructeur est créé avec succès. Mais le destructeur ne s'exécute pas parce que nous avons lancé une exception pour le mauvais pointeur faible. Il a donc affiché le code intérieur que nous avons écrit à l'intérieur de la fonction de capture qui affichait le type d'erreur qui s'est produit.

Conclusion

Dans ce guide, nous avons étudié l'exception qui est bad_weak_ptr qui est utilisée pour lancer l'exception et renvoie le type de message de l'erreur qui se produit au moment de l'exécution. Nous avons effectué différents exemples pour expliquer le concept de cette exception et comment il est utilisé dans le code. Nous avons fait de notre mieux pour expliquer le fonctionnement du bad_weak_ptr.