Ik heb OpenCV-tutorials bestudeerd en kwam de functie asserttegen; wat doet het?
Antwoord 1, autoriteit 100%
assertzal het programma beëindigen (meestal met een bericht waarin de bewering wordt geciteerd) als het argument onjuist blijkt te zijn. Het wordt vaak gebruikt tijdens het debuggen om het programma duidelijker te laten mislukken als zich een onverwachte situatie voordoet.
Bijvoorbeeld:
assert(length >= 0); // die if length is negative.
Je kunt ook een meer informatief bericht toevoegen dat moet worden weergegeven als het zo mislukt:
assert(length >= 0 && "Whoops, length can't possibly be negative! (didn't we just check 10 lines ago?) Tell jsmith");
Of anders zoals dit:
assert(("Length can't possibly be negative! Tell jsmith", length >= 0));
Als je een release (niet-debug) build doet, kun je ook de overhead van het evalueren van assert-statements verwijderen door de NDEBUG-macro te definiëren, meestal met een compiler schakelaar. Het uitvloeisel hiervan is dat uw programma nooitmag vertrouwen op het draaien van de assert-macro.
// 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);
Van de combinatie van het programma dat abort() aanroept en niet gegarandeerd iets doet, zouden beweringen alleen moeten worden gebruikt om dingen te testen die de ontwikkelaar heeft aangenomen in plaats van bijvoorbeeld dat de gebruiker een getal invoert in plaats van een letter ( die op een andere manier moet worden afgehandeld).
Antwoord 2, autoriteit 34%
De bewerencomputerverklaring is analoog aan de verklaring zorg ervoorin het Engels.
Antwoord 3, autoriteit 5%
Kijk eens naar
asset() voorbeeldprogramma in C++
Veel compilers bieden een assert()
macro. De macro assert() retourneert TRUE
als de parameter TRUE evalueert en
onderneemt een soort actie als het
beoordeelt ONWAAR. Veel compilers zullen
het programma afbreken op een assert() that
mislukt; anderen zullen een uitzondering makenEen krachtige functie van de assert()
macro is dat de preprocessor
vouwt het helemaal in tot geen code als
DEBUG is niet gedefinieerd. Het is een geweldig
helpen tijdens de ontwikkeling, en wanneer de
eindproduct wordt verzonden, er is geen
prestatieboete noch verhoging van
de grootte van de uitvoerbare versie van
het programma.
Bijv.
#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
Antwoord 4, autoriteit 3%
De functie assert() kan programmafouten diagnosticeren. In C wordt het gedefinieerd in <assert.h>, en in C++ wordt het gedefinieerd in <cassert>. Het prototype is
void assert(int expression);
De argumentuitdrukking kan alles zijn wat u wilt testen: een variabele of een willekeurige C-uitdrukking. Als expressie WAAR is, doet assert() niets. Als de uitdrukking FALSE evalueert, geeft assert() een foutmelding weer bij stderr en wordt de uitvoering van het programma afgebroken.
Hoe gebruik je assert()?Het wordt het meest gebruikt om programmafouten op te sporen (die verschillen van compilatiefouten). Een bug verhindert niet dat een programma compileert, maar zorgt er wel voor dat het onjuiste resultaten geeft of niet goed werkt (bijvoorbeeld vastlopen). Een programma voor financiële analyse dat u schrijft, kan bijvoorbeeld af en toe onjuiste antwoorden geven. U vermoedt dat het probleem wordt veroorzaakt doordat de variabele interest_rate een negatieve waarde aanneemt, wat nooit zou mogen gebeuren. Om dit te controleren, plaatst u de verklaring
beweren(interest_rate >= 0);
op locaties in het programma waar interest_rate wordt gebruikt. Als de variabele ooit negatief wordt, waarschuwt de macro assert() u. U kunt dan de relevante code onderzoeken om de oorzaak van het probleem te vinden.
Om te zien hoe assert() werkt, voer je het onderstaande voorbeeldprogramma uit. Als u een waarde invoert die niet nul is, geeft het programma de waarde weer en wordt het normaal beëindigd. Als u nul invoert, dwingt de macro assert() abnormale beëindiging van het programma af. De exacte foutmelding die u ziet, hangt af van uw compiler, maar hier is een typisch voorbeeld:
bewering mislukt: x, bestandslijst19_3.c, regel 13
Merk op dat, op volgorde van Assert () aan het werk, uw programma moet worden gecompileerd in de debug-modus. Raadpleeg de documentatie van uw compiler voor informatie over het inschakelen van debugmodus (zoals in een moment uitgelegd). Wanneer u later de definitieve versie compileert in de Release-modus, zijn de Assert () Macro’s uitgeschakeld.
int x;
printf("\nEnter an integer value: ");
scanf("%d", &x);
assert(x >= 0);
printf("You entered %d.\n", x);
return(0);
Voer een integer-waarde in: 10
u hebt 10 ingevoerd.
Voer een integer-waarde in: -1
Foutbericht:
Abnormale programmabeëindiging
Uw foutmelding kan verschillen, afhankelijk van uw systeem en compiler, maar het algemene idee is hetzelfde.
Antwoord 5
dingen zoals ‘verhoogt uitzondering’ en ‘stopt uitvoering’ zijn mogelijk waar voor de meeste compilers, maar niet voor iedereen. (BTW, zijn er bewerende verklaringen die echt uitzonderingen gooien?)
Hier is een interessante, iets andere betekenis van Assert die wordt gebruikt door C6x en andere TI-compilers: bij het zien van bepaalde verklaringen van Assert, gebruiken deze compilers de informatie in die verklaring om bepaalde optimalisaties uit te voeren. Slecht.
Voorbeeld in 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;
}
Dit vertelt de Compiler de arrays zijn uitgelijnd op 32-bitsgrenzen, dus de compiler kan specifieke instructies voor die soort uitlijning genereren.
Antwoord 6
C++ 11 N3337 Standaardontwerp
http://www.open -std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf
19.3 Beweringen
1 De kop <cassert>, beschreven in (Tabel 42), biedt een macro voor het documenteren van C++-programmabeweringen
en een mechanisme om de beweringcontroles uit te schakelen.2 De inhoud is hetzelfde als de header van de Standard C-bibliotheek <asset.h>.
C99 N1256 standaard concept
http://www.open-std .org/JTC1/SC22/WG14/www/docs/n1256.pdf
7.2 Diagnostiek <asset.h>
1 De kop
<assert.h>definieert de assert-macro en verwijst naar een andere macro,NDEBUGdie niet is gedefinieerd door<assert.h>. AlsNDEBUGis gedefinieerd als een macronaam aan de
punt in het bronbestand waar <asset.h> is opgenomen, wordt de assert-macro eenvoudig gedefinieerd als#define assert(ignore) ((void)0)De assert-macro wordt opnieuw gedefinieerd volgens de huidige status van NDEBUG elke keer dat
<assert.h>is inbegrepen.2.
De assert-macro wordt geïmplementeerd als een macro, niet als een daadwerkelijke functie. Als de
macrodefinitie wordt onderdrukt om toegang te krijgen tot een werkelijke functie, het gedrag is
niet gedefinieerd.
7.2.1 Programmadiagnose
7.2.1.1 De assert-macro
Samenvatting
1.
#include <assert.h> void assert(scalar expression);Beschrijving
2
De assert-macro zet diagnostische tests in programma’s; het breidt zich uit tot een lege uitdrukking.
Wanneer het wordt uitgevoerd, als expressie (die een scalair type zal hebben) onwaar is (dat wil zeggen,
gelijk is aan 0), schrijft de assert-macro informatie over de specifieke aanroep die
mislukt (inclusief de tekst van het argument, de naam van het bronbestand, de bronregel)
nummer, en de naam van de omsluitende functie – de laatste zijn respectievelijk de waarden van
de voorbewerkingsmacro’s__FILE__en__LINE__en van de identifier
__func__) op de standaard foutenstroom in een door de implementatie gedefinieerde indeling. 165) Het is
roept vervolgens de functie afbreken aan.Retourneren
3
De assert-macro retourneert geen waarde.
Antwoord 7
Er zijn drie hoofdredenen om de functie assert() te gebruiken boven de normale if else en printf
-
De functie
-
assessert() wordt voornamelijk gebruikt in de debugging-fase, het is vervelend om elke keer een printf-statement te schrijven als je een voorwaarde wilt testen die misschien niet eens zijn weg vindt naar de uiteindelijke code.
-
In grote software-implementaties is assert erg handig waar je de compiler de assert-statements kunt laten negeren met behulp van de NDEBUG-macro die is gedefinieerd voordat het headerbestand voor de assert()-functie wordt gekoppeld.
-
asser() is handig wanneer u een functie of een code ontwerpt en een idee wilt krijgen van welke limieten de code wel en niet zal werken en ten slotte een if else voor het evalueren ervan wilt opnemen, in feite spelend met aannames.
Antwoord 8
Het is een functie die de uitvoering van het programma stopt als de waarde die het heeft geëvalueerd onwaar is. Meestal is het omgeven door een macro, zodat het niet wordt gecompileerd in het resulterende binaire bestand wanneer het wordt gecompileerd met release-instellingen.
Het is ontworpen om te worden gebruikt voor het testen van de aannames die je hebt gemaakt. Bijvoorbeeld:
void strcpy(char* dest, char* src){
//pointers shouldn't be null
assert(dest!=null);
assert(src!=null);
//copy string
while(*dest++ = *src++);
}
Het ideaal dat je wilt, is dat je een fout kunt maken in je programma, zoals het aanroepen van een functie met ongeldige argumenten, en je raakt een assert voordat het segfouten maakt (of niet werkt zoals verwacht)
Antwoord 9
Bovendien kunt u het gebruiken om te controleren of de dynamische toewijzing is gelukt.
Codevoorbeeld:
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.
Vergelijkbaar met:
if (p == NULL) {
cout << "dynamic allocation failed" << endl;
exit(1);
}