c assert assertion handling c with examples
Questo tutorial di asserzione in C ++ fa luce sulle asserzioni in C ++ che sono dichiarazioni per testare le ipotesi nel programma fatte dal programmatore:
come testare manualmente sql injection
In un programma C ++, di solito facciamo ipotesi in un programma come un indice di matrice dovrebbe essere maggiore di zero.
Quando queste ipotesi si avverano, il programma esegue la multa ma quando queste ipotesi diventano false, il programma non termina normalmente.
=> Visita qui per il corso completo C ++ degli esperti.
Cosa imparerai:
Asserzioni in C ++
Un'asserzione è un'istruzione in C ++ che verifica una condizione come quella spiegata sopra. Se la condizione è vera, il programma continua normalmente e se la condizione è falsa, il programma viene terminato e viene visualizzato un messaggio di errore.
Possiamo fornire un'asserzione utilizzando una macro assert del preprocessore.
Con l'intero myInt, possiamo dichiarare un'asserzione che dice che myInt dovrebbe essere> 0 nel modo seguente.
assert (myInt > 0);Supponiamo che il valore di myInt specificato sia -1, quindi l'asserzione fallisce quando il compilatore incontra l'istruzione precedente poiché il valore di myInt è -1. Una volta che l'asserzione fallisce, viene emesso un messaggio che indica un'asserzione non valida insieme al nome del programma e al numero di riga e il programma viene terminato.
Un prototipo generale di assert è il seguente:
assert (condition) dove condition => espressione di tipo scalare
Un'asserzione è una macro del preprocessore utilizzata per valutare un'espressione condizionale. Se l'espressione condizionale restituisce false, il programma viene terminato dopo aver visualizzato il messaggio di errore. Il messaggio di errore consiste in genere nell'espressione condizionale non riuscita, nel nome del file di codice e nel numero di riga dell'asserzione.
Così veniamo a sapere dove si è verificato il problema e qual è il problema che si è verificato nel codice. Quindi l'uso delle asserzioni rende il debug più efficiente.
L'intestazione C ++< cassert > contiene la funzionalità di asserzione. Utilizziamo principalmente la funzionalità di asserzione nel codice per verificare se i parametri passati a una funzione sono validi, per controllare il valore di ritorno di una funzione o per controllare i limiti dell'array tra le altre cose.
Esempio di base di asserzione C ++.
#include #include using namespace std; void display_number(int* myInt) { assert (myInt!=NULL); cout<<'myInt contains value' << ' = '<<*myInt< Produzione:
Nel programma precedente, abbiamo utilizzato una chiamata assert che contiene l'espressione (myInt! = NULL) nella funzione display_number. Nella funzione principale, passiamo prima una variabile puntatore second_ptr che contiene l'indirizzo della variabile myptr. Quando viene effettuata questa chiamata, l'affermazione è vera. Quindi l'esecuzione del programma è normale e il valore viene visualizzato.
Nella seconda chiamata a display_number, passiamo il puntatore null rendendo così assert falso. Pertanto, quando viene effettuata la seconda chiamata, il messaggio di asserzione non riuscita viene visualizzato come mostrato nell'output.
Disattivazione dell'asserzione con NDEBUG
Quando utilizziamo le asserzioni, vengono verificate in fase di esecuzione. Le asserzioni rendono efficiente il debug, ma è necessario prestare attenzione a non includere asserzioni nella build di rilascio dell'applicazione. Questo perché sappiamo che quando rilasciamo un'applicazione, lo facciamo solo quando siamo sicuri che l'applicazione sia stata testata a fondo.
Quindi dobbiamo disabilitare tutte le asserzioni quando rilasciamo il software. Possiamo disabilitare le asserzioni in un programma utilizzando la macro NDEBUG. L'utilizzo della macro NDEBUG in un programma disabilita tutte le chiamate all'asserzione.
Possiamo includere una riga indicata di seguito nel programma per disabilitare tutte le istruzioni assert.
#define NDEBUG I seguenti programmi C ++ mostrano come si comporta il programma quando NDEBUG è commentato così come quando NDEBUG è attivo.
# 1) NDEBUG specificato ma commentato.
#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
'; } Produzione:
VPN Germania
In questo programma, abbiamo specificato l'istruzione #define NDEBUG ma è commentata. Ciò significa che l'istruzione assert è attiva. Pertanto, quando il programma viene eseguito, la seconda chiamata ad asserire restituisce false e viene visualizzato un messaggio di errore e il programma viene interrotto.
# 2) NDEBUG è attivo.
#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
'; } Produzione:
In questo programma, abbiamo decommentato la macro NDEBUG. Ora, quando eseguiamo il programma, le istruzioni assert non sono più attive. Quindi il programma continua la sua normale esecuzione anche quando la seconda condizione nell'istruzione assert è falsa.
Quindi decommentando la riga #define NDEBUG, abbiamo disabilitato le istruzioni assert nel programma.
Assert e static_assert
L'asserzione che abbiamo visto finora viene eseguita in fase di esecuzione. C ++ supporta ancora un'altra forma di asserzione nota come static_assert ed esegue il controllo delle asserzioni in fase di compilazione. È presente da C ++ 11.
Un static_assert ha la seguente sintassi generale.
static_assert (bool_constexpr, message)Qui bool_constexpr => c Espressione costante convertita contestualmente di tipo bool.
Message => Stringa che apparirà come messaggio di errore se bool_constexpr è falso.
Quindi, se bool_constexpr restituisce true, il programma procede normalmente. Se bool_constexpr restituisce false, viene emesso un errore del compilatore.
Il programma seguente mostra l'utilizzo di static_assert in un programma C ++.
come riprodurre file .jar
#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
'; } Produzione:
Nel programma precedente, abbiamo fornito a static_assert un'espressione e un messaggio. Quando fallisce, viene emesso un errore del compilatore come mostrato nell'output.
Domande frequenti
D # 1) Che cos'è Assert in C ++?
Risposta: Un'asserzione in C ++ è una macro predefinita con la quale possiamo testare alcuni presupposti impostati nel programma. Quando l'espressione condizionale in un'istruzione assert è impostata su true, il programma continua normalmente. Ma quando l'espressione è falsa, viene emesso un messaggio di errore e il programma viene terminato.
Q # 2) Cos'è static_assert?
Risposta: Static_assert viene valutato in fase di compilazione rispetto all'istruzione assert () valutata in fase di esecuzione.
Static_assert è stato incorporato in C ++ da C ++ 11 in poi. Richiede l'espressione condizionale e un messaggio da visualizzare come argomenti. Quando la condizione restituisce false, viene emesso un errore del compilatore e viene visualizzato il messaggio. Il programma viene quindi terminato.
D # 3) Qual è lo scopo della macro assert ()?
Risposta: La macro Assert () viene utilizzata per verificare le condizioni o le ipotesi che non dovrebbero verificarsi in un programma. Per esempio, l'indice dell'array dovrebbe sempre essere> 0. Un'altra ipotesi può essere 2 + 2 == 3 + 1.
Quindi usando assert () possiamo testare tali presupposti e fintanto che restituiscono true, il nostro programma funziona normalmente. Quando sono false, il programma viene terminato.
Conclusione
In questo tutorial, abbiamo visto il funzionamento delle istruzioni assert () in C ++. L'istruzione assert () è definita nell'intestazione. Possiamo disabilitare l'asserzione usando la macro NDEBUG. Gli sviluppatori dovrebbero fare attenzione che assert non possa essere utilizzato nel codice di produzione poiché ci si aspetta che il codice di produzione sia testato a fondo e sia privo di bug.
Oltre all'istruzione assert (), C ++ 11 supporta anche static_assert () che viene valutata in fase di compilazione. Quando static_asset () restituisce false, viene emesso un errore del compilatore e il programma viene terminato.
Le asserzioni sono un modo per testare le ipotesi nel programma e valutando le espressioni condizionali all'interno delle asserzioni, possiamo testare a fondo il programma e il debug diventa più efficiente.
=> Controlla TUTTI i tutorial di C ++ qui.
Lettura consigliata
- Esercitazione sulla gestione delle eccezioni C # con esempi di codice
- Esempi di asserzioni di selenio - Applicazioni pratiche nei progetti
- Struttura del programma C # e sintassi di base con esempi
- Tutorial Python DateTime con esempi
- Comando Taglia in Unix con esempi
- Sintassi dei comandi Cat Unix, opzioni con esempi
- Utilizzo del cursore in MongoDB con esempi
- Comando Ls in Unix con esempi
