Menü

C ++ Assert (): Assertionsbehandlung in C ++ mit Beispielen

  • Haupt
  • Andere
  • C ++ Assert (): Assertionsbehandlung in C ++ mit Beispielen

c assert assertion handling c with examples

Versuchen Sie Unser Instrument, Um Probleme Zu Beseitigen

Dieses C ++ - Assert-Tutorial beleuchtet Aussagen in C ++, bei denen es sich um Anweisungen zum Testen der Annahmen in dem vom Programmierer erstellten Programm handelt:

Fragen und Antworten zum Testen von Datenbanktests für erfahrene Personen

In einem C ++ - Programm gehen wir normalerweise davon aus, dass ein Array-Index größer als Null sein sollte.

Wenn diese Annahmen wahr werden, führt das Programm die Geldstrafe aus, aber wenn diese Annahmen falsch werden, endet das Programm nicht normal.

=> Besuchen Sie hier für den vollständigen C ++ - Kurs von Experten.

Assertionsbehandlung in C ++

Was du lernen wirst:

Behauptungen in C ++

Eine Zusicherung ist eine Anweisung in C ++, die auf eine Bedingung wie die oben erläuterte prüft. Wenn die Bedingung wahr ist, wird das Programm normal fortgesetzt, und wenn die Bedingung falsch ist, wird das Programm beendet und eine Fehlermeldung angezeigt.

Wir können eine Assertion mithilfe eines Assert-Präprozessor-Makros bereitstellen.

Mit der Ganzzahl myInt können wir eine Behauptung deklarieren, die besagt, dass myInt auf folgende Weise> 0 sein sollte.

assert (myInt > 0);

Angenommen, der angegebene Wert von myInt ist -1, daher schlägt die Zusicherung fehl, wenn der Compiler auf die obige Anweisung stößt, da myInt-Wert -1 ist. Sobald die Zusicherung fehlschlägt, wird eine Nachricht mit der Angabe einer ungültigen Zusicherung zusammen mit dem Programmnamen und der Zeilennummer ausgegeben und das Programm beendet.

Ein allgemeiner Prototyp der Behauptung lautet wie folgt:

assert (Bedingung) wobei Bedingung => Ausdruck des Skalartyps

Ein Assert ist ein Präprozessor-Makro, mit dem ein bedingter Ausdruck ausgewertet wird. Wenn der bedingte Ausdruck false ergibt, wird das Programm nach Anzeige der Fehlermeldung beendet. Die Fehlermeldung besteht normalerweise aus dem fehlgeschlagenen bedingten Ausdruck, dem Namen der Codedatei und der Zeilennummer der Bestätigung.

So erfahren wir, wo das Problem aufgetreten ist und welches Problem im Code aufgetreten ist. Die Verwendung von Zusicherungen macht das Debuggen daher effizienter.

Der C ++ - Header< Kassierer > enthält die Assert-Funktionalität. Wir verwenden meistens die Assert-Funktionalität im Code, um zu überprüfen, ob die an eine Funktion übergebenen Parameter gültig sind, um den Rückgabewert einer Funktion zu überprüfen oder um unter anderem die Array-Grenzen zu überprüfen.

Grundlegendes Beispiel für die C ++ - Assertion.

#include #include using namespace std; void display_number(int* myInt) { assert (myInt!=NULL); cout<<'myInt contains value' << ' = '<<*myInt<

Ausgabe:

C ++ Behauptung

Im obigen Programm haben wir einen Assert-Aufruf verwendet, der den Ausdruck (myInt! = NULL) in der Funktion display_number enthält. In der Hauptfunktion übergeben wir zuerst eine Zeigervariable second_ptr, die die Adresse der Variablen myptr enthält. Wenn dieser Aufruf erfolgt, ist die Behauptung wahr. Daher ist die Programmausführung normal und der Wert wird angezeigt.

Beim zweiten Aufruf von display_number übergeben wir den Nullzeiger, wodurch assert false wird. Wenn also der zweite Anruf getätigt wird, wird als Assertion Failed-Meldung angezeigt, wie in der Ausgabe gezeigt.

Deaktivieren der Bestätigung mit NDEBUG

Wenn wir Zusicherungen verwenden, werden diese zur Laufzeit überprüft. Assertions machen das Debuggen effizient, es sollte jedoch darauf geachtet werden, Assertions nicht in den Release-Build der Anwendung aufzunehmen. Dies liegt daran, dass wir wissen, dass wir eine Anwendung nur dann freigeben, wenn wir sicher sind, dass die Anwendung gründlich getestet wurde.

Daher müssen wir alle Zusicherungen deaktivieren, wenn wir die Software veröffentlichen. Wir können Zusicherungen in einem Programm mithilfe des NDEBUG-Makros deaktivieren. Die Verwendung des NDEBUG-Makros in einem Programm deaktiviert alle zu bestätigenden Aufrufe.

Wir können eine unten angegebene Zeile in das Programm aufnehmen, um alle Assert-Anweisungen zu deaktivieren.

#define NDEBUG

Das Folgen von C ++ - Programmen zeigt, wie sich das Programm verhält, wenn NDEBUG kommentiert wird und wenn NDEBUG aktiv ist.

# 1) NDEBUG angegeben, aber kommentiert.

#include // uncomment to disable assert() //#define NDEBUG #include using namespace std; int main() { assert(2+2==3+1); cout << 'Expression valid...Execution continues. '; assert(2+2==1+1); cout << 'Asset disabled...execution continuous with invalid expression '; }

Ausgabe:

express VPN Deutschland

NDEBUG angegeben, aber kommentiert.

In diesem Programm haben wir die Anweisung #define NDEBUG angegeben, diese ist jedoch kommentiert. Dies bedeutet, dass die assert-Anweisung aktiv ist. Wenn das Programm ausgeführt wird, gibt der zweite Aufruf zum Bestätigen false zurück und eine Fehlermeldung wird geflasht und das Programm wird abgebrochen.

# 2) NDEBUG ist aktiv.

#include // uncomment: assert() disabled #define NDEBUG #include using namespace std; int main() { assert(2+2==3+1); cout << 'Expression valid...Execution continues. '; assert(2+2==1+1); cout << 'Assert disabled...execution continuous with invalid expression '; }

Ausgabe:

NDEBUG ist aktiv.

In diesem Programm haben wir das NDEBUG-Makro auskommentiert. Wenn wir nun das Programm ausführen, sind die assert-Anweisungen nicht mehr aktiv. Daher setzt das Programm seine normale Ausführung fort, selbst wenn die zweite Bedingung in der assert-Anweisung falsch ist.

Durch Auskommentieren der Zeile #define NDEBUG haben wir daher die assert-Anweisungen im Programm deaktiviert.

Assert und static_assert

Die Behauptung, die wir bisher gesehen haben, wird zur Laufzeit ausgeführt. C ++ unterstützt noch eine andere Form von Assert, die als static_assert bekannt ist, und führt eine Assertionsprüfung zur Kompilierungszeit durch. Es ist seit C ++ 11 vorhanden.

Ein static_assert hat die folgende allgemeine Syntax.

static_assert (bool_constexpr, message)

Hier bool_constexpr => cKontextuell konvertierter konstanter Ausdruck vom Typ bool.

Nachricht => Zeichenfolge, die als Fehlermeldung angezeigt wird, wenn bool_constexpr false ist.

Wenn also bool_constexpr als true ausgewertet wird, wird das Programm normal fortgesetzt. Wenn bool_constexpr als false ausgewertet wird, wird ein Compilerfehler ausgegeben.

Das folgende Programm zeigt die Verwendung von static_assert in einem C ++ - Programm.

#include #include using namespace std; int main() { assert(2+2==3+1); static_assert(2+2==3+1, '2+2 = 3+1'); cout << 'Expression valid...Execution continues. '; assert(2+2==1+1); static_assert(2+2==1+1, '2+2 != 1+1'); cout << 'Assert disabled...execution continuous with invalid expression '; }

Ausgabe:

static_assert - Ausgabe

Im obigen Programm haben wir static_assert mit einem Ausdruck und einer Nachricht versehen. Wenn dies fehlschlägt, wird ein Compilerfehler ausgegeben, wie in der Ausgabe gezeigt.

Häufig gestellte Fragen

F # 1) Was ist Assert in C ++?

Antworten: Eine Zusicherung in C ++ ist ein vordefiniertes Makro, mit dem wir bestimmte Annahmen testen können, die im Programm festgelegt sind. Wenn der bedingte Ausdruck in einer assert-Anweisung auf true gesetzt ist, wird das Programm normal fortgesetzt. Wenn der Ausdruck jedoch falsch ist, wird eine Fehlermeldung ausgegeben und das Programm beendet.

F # 2) Was ist static_assert?

Antworten: Static_assert wird zur Kompilierungszeit im Vergleich zur assert () - Anweisung ausgewertet, die zur Laufzeit ausgewertet wird.

Static_assert wurde ab C ++ 11 in C ++ integriert. Der bedingte Ausdruck und eine Nachricht müssen als Argumente angezeigt werden. Wenn die Bedingung als falsch ausgewertet wird, wird ein Compilerfehler ausgegeben und die Meldung angezeigt. Das Programm wird dann beendet.

F # 3) Was ist der Zweck des Makros assert ()?

Antworten: Das Assert () -Makro wird verwendet, um die Bedingungen oder Annahmen zu testen, die in einem Programm nicht auftreten sollten. Beispielsweise, Der Array-Index sollte immer> 0 sein. Eine andere Annahme kann 2 + 2 == 3 + 1 sein.

Mit assert () können wir solche Annahmen testen. Solange sie als wahr ausgewertet werden, läuft unser Programm normal. Wenn sie falsch sind, wird das Programm beendet.

Fazit

In diesem Tutorial haben wir die Funktionsweise von assert () - Anweisungen in C ++ gesehen. Die assert () - Anweisung wird im Header definiert. Wir können die Zusicherung mit dem NDEBUG-Makro deaktivieren. Entwickler sollten darauf achten, dass assert nicht im Produktionscode verwendet werden kann, da erwartet wird, dass der Produktionscode gründlich getestet wird und fehlerfrei ist.

Neben der assert () - Anweisung unterstützt C ++ 11 auch static_assert (), das zur Kompilierungszeit ausgewertet wird. Wenn static_asset () als false ausgewertet wird, wird ein Compilerfehler ausgegeben und das Programm beendet.

Assertions sind eine Möglichkeit, die Annahmen im Programm zu testen. Durch Auswerten der bedingten Ausdrücke in Assertions können wir das Programm gründlich testen und das Debuggen wird effizienter.

Unterschied zwischen Blackbox- und Whitebox-Tests

=> Überprüfen Sie ALLE C ++ - Tutorials hier.

Literatur-Empfehlungen

^