Quelle est la fonction "assert"?
J'ai étudié les tutoriels OpenCV et suis tombé sur la fonction assert; Qu'est ce que ça fait?
assert mettra fin au programme (généralement avec un message citant l'instruction assert) si son argument s'avère être faux. Il est couramment utilisé lors du débogage pour que le programme échoue plus clairement si une condition inattendue se produit.
Par exemple:
assert(length >= 0); // die if length is negative.
Vous pouvez également ajouter un message plus informatif à afficher s'il échoue de la manière suivante:
assert(length >= 0 && "Whoops, length can't possibly be negative! (didn't we just check 10 lines ago?) Tell jsmith");
Ou alors comme ça:
assert(("Length can't possibly be negative! Tell jsmith", length >= 0));
Lorsque vous créez une version (sans débogage), vous pouvez également supprimer le surcoût lié à l'évaluation des instructions assert en définissant la macro NDEBUG, généralement à l'aide d'un commutateur de compilation. Le corollaire de ceci est que votre programme devrait jamais compter sur la macro assert en cours d'exécution.
// BAD
assert(x++);
// GOOD
assert(x);
x++;
// Watch out! Depends on the function:
assert(foo());
// Here's a safer way:
int ret = foo();
assert(ret);
De la combinaison du programme appelant abort () et n’ayant aucune garantie de faire quoi que ce soit, les assertions ne devraient être utilisées que pour tester des choses que le développeur a assumées plutôt que, par exemple, l’utilisateur qui entre un nombre plutôt qu’une lettre (qui devrait être manipulés par d'autres moyens).
L'instruction assert computer est analogue à l'instruction assurez-vous en anglais.
Jeter un coup d'œil à
exemple de programme assert () en C++
De nombreux compilateurs proposent une macro assert (). La macro assert () retourne TRUE si son paramètre évalue TRUE et effectue une action si elle évalue FALSE. De nombreux compilateurs abandonneront le programme sur un assert () qui échouera; d'autres vont lancer une exception
Une caractéristique puissante de la macro assert () est que le préprocesseur le réduit en aucun code si DEBUG n'est pas défini. C'est une aide précieuse lors du développement et lorsque le produit final est livré, il n'y a aucune perte de performances ni augmentation de la taille de la version exécutable du programme.
Par exemple
#include <stdio.h>
#include <assert.h>
void analyze (char *, int);
int main(void)
{
char *string = "ABC";
int length = 3;
analyze(string, length);
printf("The string %s is not null or empty, "
"and has length %d \n", string, length);
}
void analyze(char *string, int length)
{
assert(string != NULL); /* cannot be NULL */
assert(*string != '\0'); /* cannot be empty */
assert(length > 0); /* must be positive */
}
/**************** Output should be similar to ******************
The string ABC is not null or empty, and has length 3
La fonction assert () peut diagnostiquer les bogues du programme. Il est défini dans <assert.h>, et son prototype est
void assert(int expression);
L'argument expression peut être ce que vous voulez tester - une variable ou une expression C. Si expression est évaluée à TRUE, assert () ne fait rien. Si expression est évaluée à FALSE, assert () affiche un message d'erreur sur stderr et abandonne l'exécution du programme.
Comment utilisez-vous assert ()? Il est le plus souvent utilisé pour traquer les bogues du programme (qui sont distincts des erreurs de compilation). Un bogue n'empêche pas un programme de compiler, mais provoque des résultats incorrects ou une exécution incorrecte (verrouillage, par exemple). Par exemple, un programme d'analyse financière que vous écrivez peut parfois donner des réponses incorrectes. Vous pensez que le problème est dû à la valeur négative de la variable interest_rate, qui ne devrait jamais se produire. Pour vérifier cela, placez la déclaration
assert (taux d'intérêt> = 0); aux emplacements du programme où interest_rate est utilisé. Si la variable devient un jour négative, la macro assert () vous alerte. Vous pouvez ensuite examiner le code approprié pour localiser la cause du problème.
Pour voir comment assert () fonctionne, lancez l'exemple de programme ci-dessous. Si vous entrez une valeur différente de zéro, le programme affiche la valeur et se termine normalement. Si vous entrez zéro, la macro assert () force la fin anormale du programme. Le message d'erreur exact que vous voyez dépend de votre compilateur, mais voici un exemple typique:
L'assertion a échoué: x, file list19_3.c, ligne 13 Notez que, pour que assert () fonctionne, votre programme doit être compilé en mode débogage. Reportez-vous à la documentation de votre compilateur pour plus d'informations sur l'activation du mode débogage (comme expliqué dans un moment). Lorsque vous compilez ultérieurement la version finale en mode édition, les macros assert () sont désactivées.
int x;
printf("\nEnter an integer value: ");
scanf("%d", &x);
assert(x >= 0);
printf("You entered %d.\n", x);
return(0);
Entrez une valeur entière: 10
Vous avez entré 10.
Entrez une valeur entière: -1
Message d'erreur: Arrêt anormal du programme
Votre message d'erreur peut différer selon votre système et votre compilateur, mais l'idée générale est la même.
Des options telles que "déclenche une exception" et "arrête l'exécution" pourraient s'appliquer à la plupart des compilateurs, mais pas à tous. (BTW, y a-t-il des assertions qui jettent vraiment des exceptions?)
Voici une signification intéressante et légèrement différente d'assert utilisée par c6x et d'autres compilateurs TI: après avoir vu certaines instructions d'assert, ces compilateurs utilisent les informations contenues dans cette instruction pour effectuer certaines optimisations. Méchant.
Exemple en C:
int dot_product(short *x, short *y, short z)
{
int sum = 0
int i;
assert( ( (int)(x) & 0x3 ) == 0 );
assert( ( (int)(y) & 0x3 ) == 0 );
for( i = 0 ; i < z ; ++i )
sum += x[ i ] * y[ i ];
return sum;
}
Cela indique au compilateur que les tableaux sont alignés sur des limites de 32 bits. Le compilateur peut donc générer des instructions spécifiques pour ce type d'alignement.
Il existe trois raisons principales pour utiliser la fonction assert () par rapport à la normale si else et printf
la fonction assert () étant principalement utilisée dans la phase de débogage, il est fastidieux d’écrire si sinon avec une instruction printf à chaque fois que vous souhaitez tester une condition qui pourrait même ne pas se retrouver dans le code final.
Dans les grands déploiements de logiciels, assert est très pratique car vous pouvez faire en sorte que le compilateur ignore les instructions d'assert à l'aide de la macro NDEBUG définie avant de lier le fichier d'en-tête à la fonction assert ().
assert () est pratique lorsque vous concevez une fonction ou un code et que vous souhaitez vous faire une idée de ce qui limitera le code et ne fonctionnera pas. Pour finir, incluez un autre élément permettant de l'évaluer en jouant avec des hypothèses.
Projet de norme C++ 11 N3337
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf
19.3 Assertions
1 L'en-tête <cassert>, décrit dans (Tableau 42), fournit une macro pour documenter les assertions de programmes C++ et un mécanisme pour désactiver les contrôles d'assertion.
2 Le contenu est identique à celui de l'en-tête de bibliothèque Standard C <assert.h>.
Projet de norme C99 N1256
http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf
7.2 Diagnostics <assert.h>
1 L'en-tête
<assert.h>définit la macro d'assertion et fait référence à une autre macro,NDEBUG, qui n'est pas définie par<assert.h>. SiNDEBUGest défini comme un nom de macro au point du fichier source où <assert.h> est inclus, la macro d’assert est simplement définie comme#define assert(ignore) ((void)0)La macro d'assertion est redéfinie en fonction de l'état actuel de NDEBUG chaque fois que
<assert.h>est inclus.2. La macro assert doit être implémentée comme une macro et non comme une fonction réelle. Si la définition de macro est supprimée pour accéder à une fonction réelle, le comportement n'est pas défini.
7.2.1 Diagnostic du programme
7.2.1.1 La macro d'assertion
Synopsis
1.
#include <assert.h> void assert(scalar expression);La description
2 La macro assert insère des tests de diagnostic dans les programmes. il se développe en une expression vide. Lorsqu’elle est exécutée, si expression (qui doit avoir un type scalaire) est fausse (c’est-à-dire que la comparaison est égale à 0), la macro assert écrit des informations sur l’appel qui a échoué (y compris le texte de l’argument, le nom du fichier source, numéro de ligne source et nom de la fonction englobante - ces dernières sont respectivement les valeurs des macros de prétraitement
__FILE__et__LINE__et de l'identificateur__func__) sur le standard flux d'erreur dans un format défini par l'implémentation. 165) Il appelle ensuite la fonction d'abandon.Résultats
3 La macro assert ne renvoie aucune valeur.
Assert vous permet d'interrompre l'exécution si une condition (assertion) est fausse.
Par exemple (pseudocode):
Bank myBank = Bank.GetMyStuff();
assert(myBank != NULL);
// .. Continue.
Si myBank est NULL, la fonction arrête l'exécution et une erreur est générée. C'est très bien pour faire en sorte que du code réutilisable accepte des conditions correctes, etc.
C'est une fonction qui arrêtera l'exécution du programme si la valeur évaluée est false. Habituellement, il est entouré d'une macro afin de ne pas le compiler dans le binaire résultant lorsqu'il est compilé avec les paramètres de version.
Il est conçu pour être utilisé pour tester les hypothèses que vous avez faites. Par exemple:
void strcpy(char* dest, char* src){
//pointers shouldn't be null
assert(dest!=null);
assert(src!=null);
//copy string
while(*dest++ = *src++);
}
L'idéal que vous souhaitez est que vous puissiez commettre une erreur dans votre programme, par exemple en appelant une fonction avec des arguments non valides, et que vous frappez une assertion avant qu'elle ne se transforme (ou ne fonctionne pas comme prévu).