Quelle est la fonction de « faire valoir » ?

Question

J’ai étudié OpenCV tutoriels et suis tombé sur la `` fonction ; quel est son rôle ?

Answer 1

assert va se terminer le programme (généralement avec un message en citant l'instruction assert) si son argument s'avère être faux. il est couramment utilisé lors du débogage pour rendre le programme échec de plus, évidemment, si un problème inattendu se produit.

par exemple:

assert(length >= 0);  // die if length is negative.

Vous pouvez également ajouter un plus instructif message à afficher si elle échoue comme suit:

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

Ou autre chose comme ceci:

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

Lorsque vous êtes en train de faire une version (non-debug), vous pouvez également supprimer les frais généraux de l'évaluation de l' assert des déclarations par la définition de l' NDEBUG macro, généralement avec un commutateur de compilateur. Le corollaire de ceci est que votre programme ne devrait jamais compter sur l'assertion de la macro 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);

Answer 2

La déclaration d’ordinateur affirmer est analogue à la Déclaration s’assurer en anglais.

Answer 3

Jetez un oeil à

assert() exemple de programme en C++

De nombreux compilateurs offrent un assert() macro. La fonction assert() macro renvoie la valeur TRUE si son paramètre renvoie la valeur VRAI et prend une sorte d'action si elle renvoie la valeur FAUX. De nombreux compilateurs interrompre le programme sur un assert() échoue, d'autres seront à lancer une exception

Une fonctionnalité puissante de la fonction assert() macro, c'est que le préprocesseur s'effondre, il n'existe pas de code du tout si DEBUG n'est pas défini. C'est un grand aider au cours du développement, et lorsque la produit final bateaux il n'y a pas de les performances ni augmentation la taille de l'exécutable de la version de le 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

Answer 4

La fonction assert() peut diagnostiquer le programme de bugs. Elle est définie à l'AFFIRMER.H, et son prototype est

void assert(int expression); L'argument expression peut être quelque chose que vous voulez tester, une variable ou toute expression. Si l'expression est évaluée à VRAI, la fonction assert() ne fait rien. Si l'expression a la valeur FALSE, la fonction assert() affiche un message d'erreur sur stderr et interrompt l'exécution du programme.

Comment utilisez-vous la fonction assert()? Il est le plus fréquemment utilisé pour le suivi du programme de bugs (qui sont distincts des erreurs de compilation). Un bug qui n'empêche pas un programme à partir de la compilation, mais il la fait pour donner des résultats incorrects ou l'exécution du mal (verrouillage, par exemple). Par exemple, un financier,-l'analyse de programme que vous avez écrit peut parfois donner des réponses incorrectes. Vous pensez que le problème est causé par la variable interest_rate prendre une valeur négative, ce qui ne devrait jamais se produire. Pour ce faire, placez la déclaration

assert(interest_rate >= 0); à des endroits dans le programme où interest_rate est utilisé. Si la variable ne jamais devenir négatif, la fonction assert() macro alertes vous. Vous pouvez ensuite examiner le code afin de localiser la cause du problème.

Pour voir comment la fonction assert() fonctionne, 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 fonction assert() macro forces anormales de fin de programme. Le message d'erreur exact que vous voyez dépendent de votre compilateur, mais voici un exemple typique:

Échec de l'Assertion: x, fichier list19_3.c, ligne 13 Notez que, pour que la fonction assert (), votre programme doit être compilé en mode debug. Reportez-vous à votre documentation du compilateur pour plus d'informations sur l'activation du mode debug (comme expliqué dans un instant). Plus tard lorsque vous compiler la dernière version en mode release, le assert() les macros 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 saisi 10.

Entrez une valeur entière: -1

Message D'Erreur: Anormale de fin de programme

Votre message d'erreur peut varier en fonction de votre système et le compilateur, mais l'idée générale est la même.

Answer 5

des trucs comme "déclenche l'exception" et "interrompt l'exécution' est peut-être vrai pour la plupart des compilateurs, mais pas pour tous. (btw sont là affirmer déclarations que vraiment thrwo exceptions?)

Voici un site intéressant, différent du sens de l'affirmer utilisé par c6x et autres TI compilateurs: en voyant certains affirment consolidés, ces compilateurs utiliser les informations contenues dans cette déclaration à effectuer certaines optimisations. Méchants.

Exemple dans 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 dit de compilateur les tableaux sont alignés sur 32bits limites, de sorte que le compilateur peut générer des instructions spécifiques, pour ce type de tracé.