c assert assertion handling c with examples
Ce didacticiel d'assertions C ++ met en lumière les assertions en C ++, qui sont des instructions pour tester les hypothèses dans le programme créé par le programmeur:
comment ouvrir un fichier torrent sur mac
Dans un programme C ++, nous faisons généralement des hypothèses dans un programme comme un index de tableau devrait être supérieur à zéro.
Lorsque ces hypothèses se réalisent, le programme exécute l'amende, mais lorsque ces hypothèses deviennent fausses, le programme ne se termine pas normalement.
=> Visitez ici pour le cours C ++ complet d'experts.
Ce que vous apprendrez:
Assertions en C ++
Une assert est une instruction en C ++ qui teste une condition comme celle expliquée ci-dessus. Si la condition est vraie, le programme se poursuit normalement et si la condition est fausse, le programme se termine et un message d'erreur s'affiche.
Nous pouvons fournir une assertion en utilisant une macro de préprocesseur assert.
Avec l'entier myInt, nous pouvons déclarer une assertion disant que myInt doit être> 0 de la manière suivante.
assert (myInt > 0);
Supposons que la valeur de myInt spécifiée est -1, par conséquent l'assertion échoue lorsque le compilateur rencontre l'instruction ci-dessus car la valeur myInt est -1. Une fois que l'assertion échoue, un message indiquant une assertion invalide est émis avec le nom du programme et le numéro de ligne et le programme est arrêté.
Un prototype général d'assert est le suivant:
assert (condition) où condition => expression de type scalaire
Une assertion est une macro de préprocesseur utilisée pour évaluer une expression conditionnelle. Si l'expression conditionnelle évalue false, le programme s'arrête après l'affichage du message d'erreur. Le message d'erreur se compose généralement de l'expression conditionnelle ayant échoué, du nom du fichier de code et du numéro de ligne de l'assertion.
Ainsi, nous apprenons à savoir où le problème est survenu ainsi que quel est le problème qui s'est produit dans le code. Par conséquent, l'utilisation d'assertions rend le débogage plus efficace.
L'en-tête C ++< cassert > contient la fonctionnalité d'assert. Nous utilisons principalement la fonctionnalité d'assert dans le code pour vérifier si les paramètres passés à une fonction sont valides, pour vérifier la valeur de retour d'une fonction ou pour vérifier les limites du tableau, entre autres.
Exemple de base d'assertion C ++.
#include #include using namespace std; void display_number(int* myInt) { assert (myInt!=NULL); cout<<'myInt contains value' << ' = '<<*myInt< Production:
Dans le programme ci-dessus, nous avons utilisé un appel d'assert qui contient l'expression (myInt! = NULL) dans la fonction display_number. Dans la fonction principale, nous passons d'abord une variable de pointeur second_ptr qui contient l'adresse de la variable myptr. Lorsque cet appel est effectué, l'assertion est vraie. L'exécution du programme est donc normale et la valeur est affichée.
Dans le deuxième appel à display_number, nous transmettons le pointeur nul, rendant ainsi assert false. Ainsi, lorsque le deuxième appel est effectué, un message d'échec d'assertion s'affiche comme indiqué dans la sortie.
Désactivation de l'assertion avec NDEBUG
Lorsque nous utilisons des assertions, elles sont vérifiées à l'exécution. Les assertions rendent le débogage efficace, mais il faut veiller à ne pas inclure d'assertions dans la version de version de l'application. En effet, nous savons que lorsque nous publions une application, nous ne le faisons que lorsque nous sommes sûrs que l'application est testée de manière approfondie.
Nous devons donc désactiver toutes les assertions lorsque nous publions le logiciel. Nous pouvons désactiver les assertions dans un programme en utilisant la macro NDEBUG. L'utilisation de la macro NDEBUG dans un programme désactive tous les appels à assert.
Nous pouvons inclure une ligne donnée ci-dessous dans le programme pour désactiver toutes les instructions assert.
#define NDEBUG
Les programmes C ++ suivants montrent comment le programme se comporte lorsque NDEBUG est commenté ainsi que lorsque NDEBUG est actif.
# 1) NDEBUG spécifié mais commenté.
#include // uncomment to disable assert() //#define NDEBUG #include using namespace std; int main() { assert(2+2==3+1); cout << 'Expression valid...Execution continues.
'; assert(2+2==1+1); cout << 'Asset disabled...execution continuous with invalid expression
'; }
Production:
serveur VPN Allemagne
Dans ce programme, nous avons spécifié l'instruction #define NDEBUG mais est commentée. Cela signifie que l'instruction assert est active. Ainsi, lorsque le programme est exécuté, le deuxième appel à assert retourne faux et un message d'erreur clignote et le programme est abandonné.
# 2) NDEBUG est actif.
#include // uncomment: assert() disabled #define NDEBUG #include using namespace std; int main() { assert(2+2==3+1); cout << 'Expression valid...Execution continues.
'; assert(2+2==1+1); cout << 'Assert disabled...execution continuous with invalid expression
'; }
Production:
Dans ce programme, nous avons décommenté la macro NDEBUG. Maintenant, lorsque nous exécutons le programme, les instructions assert ne sont plus actives. Par conséquent, le programme continue son exécution normale même lorsque la deuxième condition de l'instruction assert est fausse.
Ainsi, en décommentant la ligne #define NDEBUG, nous avons désactivé les instructions assert dans le programme.
Assert et static_assert
L'assertion que nous avons vue jusqu'à présent est exécutée au moment de l'exécution. C ++ prend en charge une autre forme d'assert connue sous le nom de static_assert et effectue une vérification d'assertion à la compilation. Il est présent depuis C ++ 11.
Un static_assert a la syntaxe générale suivante.
static_assert (bool_constexpr, message)
Ici bool_constexpr => cExpression constante convertie de manière contextuelle de type bool.
Message => Chaîne qui apparaîtra sous forme de message d'erreur si bool_constexpr est false.
Donc, si bool_constexpr prend la valeur true, le programme se déroule normalement. Si bool_constexpr prend la valeur false, une erreur de compilation est émise.
Le programme ci-dessous montre l'utilisation de static_assert dans un programme C ++.
#include #include using namespace std; int main() { assert(2+2==3+1); static_assert(2+2==3+1, '2+2 = 3+1'); cout << 'Expression valid...Execution continues.
'; assert(2+2==1+1); static_assert(2+2==1+1, '2+2 != 1+1'); cout << 'Assert disabled...execution continuous with invalid expression
'; }
Production:
Dans le programme ci-dessus, nous avons fourni à static_assert une expression et un message. En cas d'échec, une erreur du compilateur est émise comme indiqué dans la sortie.
Questions fréquemment posées
Q # 1) Qu'est-ce que Assert en C ++?
Répondre: Une assertion en C ++ est une macro prédéfinie à l'aide de laquelle nous pouvons tester certaines hypothèses définies dans le programme. Lorsque l'expression conditionnelle dans une instruction assert est définie sur true, le programme se poursuit normalement. Mais lorsque l'expression est fausse, un message d'erreur est émis et le programme est arrêté.
Q # 2) Qu'est-ce que static_assert?
Répondre: Static_assert est évalué au moment de la compilation par rapport à l'instruction assert () qui est évaluée au moment de l'exécution.
Static_assert a été incorporé en C ++ à partir de C ++ 11. Il faut que l'expression conditionnelle et un message soient affichés comme arguments. Lorsque la condition est évaluée à false, une erreur du compilateur est émise et le message s'affiche. Le programme est alors terminé.
Q # 3) Quel est le but de la macro assert ()?
Répondre: La macro Assert () est utilisée pour tester les conditions ou les hypothèses qui ne devraient pas se produire dans un programme. Par exemple, l'index du tableau doit toujours être> 0. Une autre hypothèse peut être 2 + 2 == 3 + 1.
Donc, en utilisant assert (), nous pouvons tester de telles hypothèses et tant qu'elles sont évaluées à vrai, notre programme fonctionne normalement. Quand ils sont faux, le programme est arrêté.
Conclusion
Dans ce tutoriel, nous avons vu le fonctionnement des instructions assert () en C ++. L'instruction assert () est définie dans l'en-tête. Nous pouvons désactiver l'assert en utilisant la macro NDEBUG. Les développeurs doivent veiller à ce que l'assert ne puisse pas être utilisé dans le code de production car il est prévu que le code de production soit testé de manière approfondie et sans bogue.
comment créer un nouveau projet java dans eclipse
Outre l'instruction assert (), C ++ 11 prend également en charge static_assert () qui est évaluée au moment de la compilation. Lorsque static_asset () prend la valeur false, une erreur de compilation est émise et le programme se termine.
Les assertions sont un moyen de tester les hypothèses dans le programme et en évaluant les expressions conditionnelles à l'intérieur des assertions, nous pouvons tester le programme à fond et le débogage devient plus efficace.
=> Consultez TOUS les didacticiels C ++ ici.
lecture recommandée
- Tutoriel sur la gestion des exceptions C # avec des exemples de code
- Exemples d'assertion de sélénium - Applications pratiques dans les projets
- Structure du programme C # et syntaxe de base avec des exemples
- Tutoriel Python DateTime avec des exemples
- Commande Cut sous Unix avec des exemples
- Syntaxe des commandes Unix Cat, options avec exemples
- Utilisation du curseur dans MongoDB avec des exemples
- Commande Ls sous Unix avec des exemples