Come al minimo uso
Includa denullpo.h in ogni fonte di C/C++, ma ha bisogno di setting, altrimenti tutte le macro in denullpo.h divenuto nullo.
Ogni setting è scritto in "#define" di fronte ad incluso denullpo.h.
- DENULLPO_TRAP
- Se questo è definito, callback di scoperta di errore diviene effettivo.
- DENULLPO_SKIP
- Se questo è definito, Denullpo scopre errori.
- Se né DENULLPO_TRAP né DENULLPO_SKIP è definito, Denullpo non scopre errori.
- DENULLPO_4CC
- È un valore da indicare che un esempio è valido.
- Se questo non è definito, è definito automaticamente ad un valore continuo.
Alla macchia che dovrebbe controllare un cursore, lo dia in un cursore in
denullpo().
Quando un cursore è NULL, Denullpo tratta un errore fisso.
Sample Code
/*=== evada accesso ad un cursore NULL con denullpo() ===*/
#include <stdio.h>
/*=== Denullpo ha bisogno di setting prima incluso denullpo.h ===*/
/*=== Lei può rimuovere maneggio di Denullpo quando Lei cambia questa linea in commento. ===*/
#define DENULLPO_SKIP
#include "denullpo.h"
int main(int argc,char *argv[]){
void* p=NULL;
int err=0;
p=malloc(128);
/*=== divide lavorazione da un risultato di controllo di un cursore ===*/
if(denullpo(p)){
/*=== trattando quando è anormale ===*/
fprintf(stderr,"this is nullpo\n");
err=1;
}
else{
/*=== trattando quando è normale ===*/
// :
// :
// :
free(p);
p=NULL;
}
return err;
}
Esamina la validità di esempio
Denullpo può esaminare la validità di esempio aggiungendo un membro per un codice magico ad una classe ed un corpo di struttura.
Classe e struttura di un obiettivo di controllo definiscono un punto di scrittura di un codice magico in DENULLPO_INITCHECKER.
Quando lo creò in esempio, indica quel esempio valido chiamando
denullpo_setinit().
E quando lo distrugge in esempio, indica quel esempio nullo chiamando
denullpo_setpurge().
Der di Bei Stelle, muoia einen sollte di überprüfen di Zeiger, geben l'es di Sie in einem Zeiger in
denullpo2().
Quando un cursore è illegale, Denullpo tratta un errore fisso.
Sample Code
/*=== resista ad una chiamata di metodo di esempio illecito ===*/
#include <stdio.h>
#define DENULLPO_SKIP
#include "denullpo.h"
class FOO{
public:
/*=== definisca un variabile riempire in una corda magica in una classe ===*/
DENULLPO_INITCHECKER;
FOO(){
/*=== riempia in una corda magica che indica che inizializzò ===*/
denullpo_setinit(this);
}
~FOO(){
/*=== riempia in una corda magica che indica che terminò ===*/
denullpo_setpurge(this);
}
void exec(){
/*=== lo tratti come un errore se questo metodo è chiamato da eccetto tra denullpo_setinit() e denullpo_setpurge() ===*/
if(denullpo2())return;
// :
// :
// :
}
};
Callback di scoperta di errore
denullpo() e
denullpo2() di solito ritornano immediatamente un risultato quando loro scoprirono un errore.
Quando Lei chiama
denullpo_settrap() e callback di set, callback si chiama quando Denullpo scoprì un errore, ed il risultato è riflesso.
DENULLPO_TRAP deve essere definito prima incluso un denullpo.h per convalidare callback.
Sample Code
/*=== perfezioni gestione errori di un cursore illecito ===*/
#include <stdio.h>
/*=== mettendo convalidare callback ===*/
#define DENULLPO_TRAP
#include "denullpo.h"
int err=0;
/*=== trattando quando Denullpo scoprì un errore ===*/
static unsigned __cdecl hook(void *p,eDenullpoReason reason){
fprintf(stderr,"nullpo is hooked\n");
err=1;
/*=== il valore che ritorna appena diviene ritornando valore di denullpo() ===*/
return 1;
}
int main(int argc,char *argv[]){
void* p=NULL;
/*=== mettendo di callback ===*/
denullpo_settrap(hook);
p=malloc(128);
/*=== Se un cursore è NULL, Denullpo esegue callback fisso. ===*/
if(!denullpo(p)){
/*=== trattando quando è normale ===*/
// :
// :
// :
free(p);
p=NULL;
}
return err;
}
Dettagli
Definizioni
eDenullpoReason
- DENULLPO_NULL
- Il cursore esaminato è NULL.
- DENULLPO_INVALID
- L'esempio esaminato è nullo.
Callback dattilografa
Callback quando l'errore è scoperto.
Argomenti
p | cursore di un obiettivo di esame |
reason | base di un errore |
Valore che ritorna
0 | Questo fattore di errore fu risolto. |
1 | Questo fattore di errore ancora è andato via. |
Funzione
trovi un callback di scoperta di errore.
Valore che ritorna
metta un callback di scoperta di errore.
Argomenti
trap | una funzione per trattare come callback |
Valore che ritorna
l'ultimo valore di setting |
Note
Questa funzione non è infilata cassaforte.
chiami il callback di scoperta di errore.
Argomenti
p | cursore di un obiettivo di esame |
reason | base di un errore |
Valore che ritorna
0 | Questo fattore di errore fu risolto. |
1 | Questo fattore di errore ancora è andato via. |
unsigned denullpo_getinit(any* p)
trovi un valore di verificatore di esempio
Argomenti
Valore che ritorna
valore di verificatore di esempio |
void denullpo_setinit(any* p)
notifichi verificatore di esempio che l'esempio è inizializzato
Argomenti
Note
Lei deve richiedere questa macro ogni esempio per divenire un obiettivo di
denullpo2().
void denullpo_setpurge(any* p)
notifichi verificatore di esempio che l'esempio è terminato
Argomenti
Note
Lei deve richiedere questa macro ogni esempio per divenire un obiettivo di
denullpo2().
unsigned denullpo_chkinit(any* p)
esamini se l'esempio è inizializzato
Argomenti
Valore che ritorna
0 | non l'anormalità |
1 | anormalità |
Note
Lei non chiama di solito direttamente questa macro. Lei chiama
denullpo2() così che Denullpo esamina esempio.
int denullpo(any* p)
esamini se un cursore è NULL
Argomenti
p | designi come bersaglio cursore |
Valore che ritorna
0 | NULL non fu scoperto |
1 | NULL fu scoperto |
Note
La funzione di callback stata chiamata in caso della scoperta di errore se è messo da una funzione di callback in
denullpo_settrap().
int denullpo2(any* p)
esamini se un esempio è nullo
Argomenti
Valore che ritorna
0 | non l'anormalità |
1 | anormalità |
Note
La funzione di callback stata chiamata in caso della scoperta di errore se è messo da una funzione di callback in
denullpo_settrap().