Como para uso mínimo
Inclua denullpo.h em cada fonte de C/C++, mas precisa de colocações, caso contrário todos os macros em denullpo.h ficam inválidos.
Toda a colocação é escrita dentro "#define" antes de inclusive denullpo.h.
- DENULLPO_TRAP
- Se isto estiver definido, callback de descoberta de erro fica efetivo.
- DENULLPO_SKIP
- Se isto estiver definido, Denullpo descobre erros.
- Se DENULLPO_TRAP nem DENULLPO_SKIP está definido, Denullpo não descobre erros.
- DENULLPO_4CC
- É um valor para indicar que um exemplo é válido.
- Se isto não estiver definido, está automaticamente definido a um valor constante.
Na mancha que deveria conferir um ponteiro, dê em um ponteiro em
denullpo().
Quando um ponteiro for NULL, Denullpo processa um erro fixo.
Sample Code
/*=== evada acesso a um ponteiro NULL com denullpo() ===*/
#include <stdio.h>
/*=== Denullpo precisa de colocação antes inclusive denullpo.h ===*/
/*=== Você pode remover manipulação de Denullpo quando você mudar esta linha em comentário. ===*/
#define DENULLPO_SKIP
#include "denullpo.h"
int main(int argc,char *argv[]){
void* p=NULL;
int err=0;
p=malloc(128);
/*=== divide processo por um resultado de cheque de um ponteiro ===*/
if(denullpo(p)){
/*=== processando quando é anormal ===*/
fprintf(stderr,"this is nullpo\n");
err=1;
}
else{
/*=== processando quando é normal ===*/
// :
// :
// :
free(p);
p=NULL;
}
return err;
}
Examina a validez de exemplo
Denullpo pode examinar a validez de exemplo acrescentando um sócio para um código mágico a uma classe e um corpo de estrutura.
Classe e estrutura de um objetivo de cheque definem um ponto de escritura de um código mágico em DENULLPO_INITCHECKER.
Quando criou isto em exemplo, indica aquele exemplo válido chamando
denullpo_setinit().
E quando destrói isto em exemplo, indica aquele exemplo de inválido chamando
denullpo_setpurge().
Der de Bei Stelle, morra einen Zeiger überprüfen sollte, geben es de Sie em einem Zeiger em
denullpo2().
Quando um ponteiro for ilegal, Denullpo processa um erro fixo.
Sample Code
/*=== resista a uma chamada de método de exemplo ilícito ===*/
#include <stdio.h>
#define DENULLPO_SKIP
#include "denullpo.h"
class FOO{
public:
/*=== defina uma variável para preencher uma corda mágica em uma classe ===*/
DENULLPO_INITCHECKER;
FOO(){
/*=== preencha uma corda mágica que indica que inicializou ===*/
denullpo_setinit(this);
}
~FOO(){
/*=== preencha uma corda mágica que indica que terminou ===*/
denullpo_setpurge(this);
}
void exec(){
/*=== trate como um erro se este método é chamado de exclua entre denullpo_setinit() e denullpo_setpurge() ===*/
if(denullpo2())return;
// :
// :
// :
}
};
Callback de descoberta de erro
denullpo() e
denullpo2() normalmente devolvem imediatamente um resultado quando eles descobriram um erro.
Quando você chamar
denullpo_settrap() e callback de jogo, callback é chamado quando Denullpo descobriu um erro, e o resultado é refletido.
DENULLPO_TRAP deve ser definido antes inclusive um denullpo.h validar callback.
Sample Code
/*=== implemente erro que controla de um ponteiro ilícito ===*/
#include <stdio.h>
/*=== fixando para validar callback ===*/
#define DENULLPO_TRAP
#include "denullpo.h"
int err=0;
/*=== processando quando Denullpo descobriu um erro ===*/
static unsigned __cdecl hook(void *p,eDenullpoReason reason){
fprintf(stderr,"nullpo is hooked\n");
err=1;
/*=== valor devolvendo há pouco se torna devolvendo valor de denullpo() ===*/
return 1;
}
int main(int argc,char *argv[]){
void* p=NULL;
/*=== fixando de callback ===*/
denullpo_settrap(hook);
p=malloc(128);
/*=== Se um ponteiro for NULL, Denullpo executam callback fixo. ===*/
if(!denullpo(p)){
/*=== processando quando é normal ===*/
// :
// :
// :
free(p);
p=NULL;
}
return err;
}
Detalhes
Definições
eDenullpoReason
- DENULLPO_NULL
- Ponteiro examinado é NULL.
- DENULLPO_INVALID
- Exemplo examinado é inválido.
Callback digita
Callback quando erro é descoberto.
Argumentos
| p | ponteiro de um objetivo de exame |
| reason | base de um erro |
Valor devolvendo
| 0 | Este fator de erro foi resolvido. |
| 1 | Este fator de erro ainda é esquerdo. |
Função
adquira um callback de descoberta de erro.
Valor devolvendo
fixe um callback de descoberta de erro.
Argumentos
| trap | uma função para tratar como callback |
Valor devolvendo
o último valor de colocação |
Notas
Esta função não é nenhuma linha seguro.
chame o callback de descoberta de erro.
Argumentos
| p | ponteiro de um objetivo de exame |
| reason | base de um erro |
Valor devolvendo
| 0 | Este fator de erro foi resolvido. |
| 1 | Este fator de erro ainda é esquerdo. |
unsigned denullpo_getinit(any* p)
adquira um valor de inspetor de exemplo
Argumentos
Valor devolvendo
valor de inspetor de exemplo |
void denullpo_setinit(any* p)
notifique inspetor de exemplo que exemplo é inicializado
Argumentos
Notas
Você tem que chamar este macro para cada exemplo se tornar um objetivo de
denullpo2().
void denullpo_setpurge(any* p)
notifique inspetor de exemplo que exemplo é terminado
Argumentos
Notas
Você tem que chamar este macro para cada exemplo se tornar um objetivo de
denullpo2().
unsigned denullpo_chkinit(any* p)
examine se exemplo é inicializado
Argumentos
Valor devolvendo
| 0 | não anormalidade |
| 1 | anormalidade |
Notas
Você normalmente não chama diretamente este macro. Você chama
denullpo2() de forma que Denullpo examina exemplo.
int denullpo(any* p)
examine se um ponteiro é NULL
Argumentos
Valor devolvendo
| 0 | NULL não foi descoberto |
| 1 | NULL foi descoberto |
Notas
A função de callback é chamada no caso da descoberta de erro se fixou por uma função de callback em
denullpo_settrap().
int denullpo2(any* p)
examine se um exemplo é inválido
Argumentos
Valor devolvendo
| 0 | não anormalidade |
| 1 | anormalidade |
Notas
A função de callback é chamada no caso da descoberta de erro se fixou por uma função de callback em
denullpo_settrap().