Qu'est-ce que la fonction «affirmer»?

J'ai étudié des tutoriels OpenCV et suis tombé sur la assertfonction; Qu'est ce que ça fait?

assertmettra fin au programme (généralement avec un message citant l'instruction assert) si son argument s'avère faux. Il est couramment utilisé pendant le débogage pour faire échouer le programme 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 en cas d'échec:

assert(length >= 0 && "Whoops, length can't possibly be negative! (didn't we just check 10 lines ago?) Tell jsmith");

Ou bien comme ça:

assert(("Length can't possibly be negative! Tell jsmith", length >= 0));

Lorsque vous effectuez une génération de version (sans débogage), vous pouvez également supprimer la surcharge des assertinstructions d' évaluation en définissant la NDEBUGmacro, généralement avec un commutateur de compilation. Le corollaire de cela est que votre programme ne doit jamais compter sur l'exécution de la macro assert.

// 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);

À partir 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 supposées plutôt que, par exemple, l'utilisateur saisissant un nombre plutôt qu'une lettre (qui devrait être traitées par d’autres moyens).

La déclaration assert computer est analogue à la déclaration 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 () renvoie VRAI si son paramètre évalue VRAI et prend une sorte d'action si elle évalue FAUX. De nombreux compilateurs abandonnent le programme sur un assert () qui échoue; d'autres lèveront une exception

Une caractéristique puissante de la macro assert () est que le préprocesseur la réduit en aucun code si DEBUG n'est pas défini. C'est une grande aide pendant le développement, et lorsque le produit final est livré, il n'y a pas de pénalité de performance ni d'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. En C, il est défini en <assert.h>et en C ++, il est défini en <cassert>. Son prototype est

void assert(int expression);

L'expression d'argument peut être tout ce que vous voulez tester - une variable ou n'importe quelle expression C. Si l'expression est évaluée à TRUE, assert () ne fait rien. Si l'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 il le fait donner des résultats incorrects ou ne pas fonctionner correctement (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û au fait que la variable interest_rate prend une valeur négative, ce qui ne devrait jamais arriver. Pour vérifier cela, placez la déclaration

assert (taux_intérêt> = 0); aux emplacements du programme où taux d'intérêt est utilisé. Si la variable devient négative, la macro assert () vous alerte. Vous pouvez ensuite examiner le code approprié pour localiser la cause du problème.

Pour voir comment fonctionne assert (), exécutez 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 verrez dépendra de votre compilateur, mais voici un exemple typique:

Échec de l'assertion: x, fichier 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 de débogage (comme expliqué dans un instant). Lorsque vous compilerez 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 trucs comme «déclenche une exception» et «arrête l'exécution» peuvent être vrais pour la plupart des compilateurs, mais pas pour tous. (BTW, y a-t-il des déclarations assert qui lèvent vraiment des exceptions?)

Voici une signification intéressante et légèrement différente d'assertion utilisée par c6x et d'autres compilateurs TI: en voyant certaines instructions assert, ces compilateurs utilisent les informations de 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, de sorte que le compilateur peut générer des instructions spécifiques faites pour ce type d'alignement.

Projet standard 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 programme C ++ et un mécanisme pour désactiver les vérifications d'assertion.

2 Le contenu est le même que l'en-tête de la bibliothèque C standard <assert.h>.

Projet standard 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, NDEBUGqui n'est pas définie par <assert.h>. Si NDEBUGest défini comme un nom de macro au point du fichier source où <assert.h> est inclus, la macro d'assertion est définie simplement comme

 #define assert(ignore) ((void)0)

La macro d'assertion est redéfinie en fonction de l'état actuel de NDEBUG chaque fois qu'il <assert.h>est inclus.

2. La macro d'assertion doit être implémentée comme une macro et non comme une fonction réelle. Si la définition de macro est supprimée afin d'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 assert

Synopsis

1.

#include <assert.h>
void assert(scalar expression);

La description

2 La macro assert place les tests de diagnostic dans les programmes; il se développe en une expression vide. Lorsqu'elle est exécutée, si l'expression (qui doit avoir un type scalaire) est fausse (c'est-à-dire qu'elle est égale à 0), la macro d'assertion écrit des informations sur l'appel particulier qui a échoué (y compris le texte de l'argument, le nom du fichier source, le numéro de ligne source et le nom de la fonction englobante - ces derniers sont respectivement les valeurs des macros de prétraitement __FILE__et __LINE__et de l'identifiant __func__) sur le flux d'erreur standard dans un format défini par l'implémentation. 165) Il appelle ensuite la fonction d'abandon.

Retour

3 La macro d'assertion ne renvoie aucune valeur.

Il y a trois raisons principales d'utiliser la fonction assert () par rapport à la normale if else et printf

1. La fonction assert () est principalement utilisée dans la phase de débogage, il est fastidieux d'écrire sinon avec une instruction printf chaque fois que vous voulez tester une condition qui pourrait même ne pas faire son chemin dans le code final.

2. Dans les grands déploiements de logiciels, assert est très pratique où vous pouvez faire ignorer au compilateur les instructions assert à l'aide de la macro NDEBUG définie avant de lier le fichier d'en-tête pour la fonction assert ().

3. assert () est pratique lorsque vous concevez une fonction ou du code et que vous souhaitez vous faire une idée des limites du code et qu'il ne fonctionnera pas et enfin inclure un if sinon pour l'évaluer en jouant essentiellement avec des hypothèses.

C'est une fonction qui arrêtera l'exécution du programme si la valeur qu'il a évaluée est fausse. Habituellement, il est entouré d'une macro afin qu'il ne soit pas compilé 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 voulez est que vous puissiez faire une erreur dans votre programme, comme appeler une fonction avec des arguments invalides, et que vous frappiez une assertion avant qu'elle ne se mette en défaut (ou ne fonctionne pas comme prévu)

De plus, vous pouvez l'utiliser pour vérifier si l'allocation dynamique a réussi.

Exemple de code:

int ** p;
p = new int * [5];      // Dynamic array (size 5) of pointers to int
for (int i = 0; i < 5; ++i) {
    p[i] = new int[3]; // Each i(ptr) is now pointing to a dynamic
                       // array (size 3) of actual int values
}

assert (p);            // Check the dynamic allocation.

Semblable à:

if (p == NULL) {
    cout << "dynamic allocation failed" << endl;
    exit(1);
}