Utilisation des assertions (assert)

J'ai toujours pensé qu'assert n'était qu'une fonction de signalement d'erreur, mais en fait, c'est une macro, et son but n'est pas le « signalement d'erreur ».

Après en avoir acquis une certaine compréhension, j'ai trouvé que l'utilisation d'assert() ressemble à une sorte de « programmation par contrat ». Selon ma compréhension, cela signifie que le programme peut fonctionner normalement et correctement dans le cadre de mes hypothèses. En fait, cela équivaut à une instruction if :

if(假设成立)
{
     程序正常运行；
}
else
{
      报错&&终止程序！（避免由程序运行引起更大的错误）  
}

Mais l'écrire de cette façon entraînerait d'innombrables instructions if, et il pourrait même arriver que les parenthèses d'une instruction if s'étendent du début à la fin d'un fichier. De plus, dans la plupart des cas, les hypothèses que nous devons vérifier ne sont que des événements accessoires, ou nous voulons simplement tester si certains scénarios de pire cas se produisent. C'est pourquoi assert() existe.

Le prototype de la macro assert est défini dans assert.h. Sa fonction est de terminer l'exécution du programme si sa condition renvoie une erreur.

#include "assert.h" 
void assert( int expression );

Le rôle d'assert est d'abord d'évaluer l'expression expression ; si sa valeur est fausse (c'est-à-dire 0), il imprime d'abord un message d'erreur sur stderr, puis termine l'exécution du programme en appelant abort.

L'inconvénient d'utiliser assert est que des appels fréquents peuvent grandement affecter les performances du programme et ajouter une surcharge supplémentaire.

Après le débogage, vous pouvez désactiver les appels à assert en insérant #define NDEBUG avant l'instruction #include. Un exemple de code est le suivant :

#include 
#define NDEBUG 
#include

Résumé d'utilisation et précautions

1) Vérifier la validité des paramètres entrants au début de la fonction.

Par exemple :

int resetBufferSize(int nNewSize) 
{ 
//功能:改变缓冲区大小, 
//参数:nNewSize 缓冲区新长度 
//返回值:缓冲区当前长度 
//说明:保持原信息内容不变 nNewSize<=0表示清除缓冲区 
assert(nNewSize >= 0); 
assert(nNewSize <= MAX_BUFFER_SIZE); 
 
... 
}

2) Chaque assert ne doit vérifier qu'une seule condition, car lorsqu'on vérifie plusieurs conditions à la fois, si l'assertion échoue, il est impossible de déterminer intuitivement quelle condition a échoué.

Pas bon :

assert(nOffset>=0 && nOffset+nSize<=m_nInfomationSize);

Bon :

assert(nOffset >= 0); 
assert(nOffset+nSize <= m_nInfomationSize);

3) N'utilisez pas d'instructions qui modifient l'environnement, car assert ne prend effet qu'en DEBUG. Si vous faites cela, cela causera des problèmes lorsque le programme s'exécutera réellement.

Faux : assert(i++ < 100)

En effet, si une erreur se produit, par exemple si i=100 avant l'exécution, cette instruction ne sera pas exécutée, donc la commande i++ ne sera pas exécutée.

Correct :

assert(i < 100)
i++;

4) Il doit y avoir une ligne vide entre assert et l'instruction suivante afin de créer une cohérence logique et visuelle.

5) À certains endroits, assert ne peut pas remplacer le filtrage conditionnel.

Les programmes sont généralement divisés en versions Debug et en versions Release. Les versions Debug servent au débogage interne, et les versions Release sont distribuées aux utilisateurs. L'assertion assert est une macro qui ne fonctionne que dans les versions Debug ; elle sert à vérifier des situations qui « ne devraient pas » se produire. Ce qui suit est un programme de copie de mémoire. Lors de l'exécution, si le paramètre de assert est faux, le programme se terminera (généralement une boîte de dialogue d'invite apparaît, indiquant où l'assertion a été déclenchée).

Voici plusieurs principes d'utilisation des assertions :

(1) Utilisez des assertions pour détecter des situations illégales qui ne devraient pas se produire. Ne confondez pas la différence entre les situations illégales et les situations d'erreur ; ces dernières existent nécessairement et doivent être traitées.
(2) Utilisez des assertions pour confirmer les paramètres des fonctions.
(3) Lorsque vous écrivez des fonctions, examinez et demandez-vous à plusieurs reprises : « Quelles hypothèses ai-je l'intention de formuler ? » Une fois qu'une hypothèse est déterminée, utilisez des assertions pour vérifier cette hypothèse.
(4) Les manuels généraux encouragent les programmeurs à pratiquer la programmation défensive, mais rappelez-vous que ce style de programmation peut masquer des erreurs. Lorsque vous pratiquez la programmation défensive, si quelque chose qui « ne peut pas se produire » se produit effectivement, utilisez des assertions pour déclencher une alerte.

ASSERT() est une macro souvent utilisée lors du débogage de programmes. À l'exécution, elle évalue l'expression entre parenthèses. Si l'expression est FALSE (0), le programme signale une erreur et termine l'exécution. Si l'expression n'est pas 0, il continue d'exécuter les instructions suivantes. Cette macro est généralement utilisée pour déterminer si des données manifestement illégales sont apparues dans le programme ; si c'est le cas, elle termine le programme afin d'éviter des conséquences graves, et elle facilite également la recherche d'erreurs.

ASSERT n'est valide que dans les versions Debug ; il est ignoré s'il est compilé en version Release.

URL d'origine : https://www.cnblogs.com/thisway/p/5558914.html

Utilisation des assertions (assert)

Catégorie Technologie de programmation

Résumé d'utilisation et précautions