test de pointeur valide en C++

J'ai écrit un petit test pour vérifier null pointeur, je l'ai simplifié avec int et 0, 1, au lieu de vraies classes, ce que j'essaie de tester est quelque chose comme: return p ? 1 : 0; dans le monde réel serait return p ? p->callmethod() : 0;test de pointeur valide en C++

bool TestTrueFalse(); 
void main() 
{ 
    int i = TestTrueFalse(); 

} 

bool TestTrueFalse() 
{ 
    int one = 1; 
    int * p =&one;  
    *p = 0; 

    return p ? 1 : 0; 
}

maintenant, vous pouvez le voir, une fois que le pointeur devient 0 à nouveau, le test échoue, pourquoi? qu'est-ce qui ne va pas avec ça? Quelle est la solution?

Source

2010-08-25 ra170

Je suis très confus par la question et le code. Si vous voulez vérifier un pointeur nul, 'if (p == 0) {...}' devrait être assez bon, non? Votre code n'utilise pas les types de données cohérents (bool vs int) et cela n'a pas beaucoup de sens non plus. – tenfour

Je ne vois pas comment le test peut échouer, vous ne définissez jamais le pointeur sur null. Le test devrait réussir. –

@tenfour: "si (p == 0) {...} devrait être assez bon, non?" 'if (! p) {...}' devrait être assez bon ... – SigTerm

*p = 0;

vous vouliez probablement dire

p = 0;

* p = 0 définit ce que les points de pointeur, pas le pointeur

Source

2010-08-25 15:12:59

Lors du test d'une valeur de pointeur avec un conditionnel en C++, il retourne vrai si la valeur est différente de zéro et false si la valeur est 0. Dans votre exemple p est prévu pour pointer sur le one local et a donc une adresse différente de zéro (même si la valeur à l'adresse est 0). Par conséquent, vous obtenez vrai

Source

2010-08-25 15:13:24 JaredPar

Un pointeur NULL est un pointeur qui pointe vers l'adresse 0, pas la valeur 0.

Pour définir un pointeur null, faites:

p = 0;

Pour élaborer, votre code définit la pointe à int à 0. Par exemple:

int i = 1; 
int *p = &i; 
assert(*p == 1); //p points to 1 

*p = 0; 
assert(*p == 0 && i == 0); //p points to the same location, but that location now contains 0

Source

2010-08-25 15:13:31

le code *p = 0; ne définit pas le pointeur nULL. Il définit ce que p pointe vers zéro.

Source

2010-08-25 15:13:58 Starkey

Un pointeur est une adresse en mémoire. int *p = &one; prend l'adresse de la variable one et la stocke dans p. *p = 0; stocke 0 dans la mémoire pointée par p, ce qui signifie que la valeur de one est maintenant 0. Donc, vous avez changé ce p points, mais pas p lui-même. TestTrueFalse() retournera 1.

Source

2010-08-25 15:14:56 Dima

pour le tester pour un pointeur NULL avant de vérifier la valeur que vous pouvez utiliser pointé code comme

if(ip != NULL)

pris de http://www.eskimo.com/~scs/cclass/notes/sx10d.html

NULL pourrait être plus sûr dans votre code, car il est plus indépendant du compilateur que d'écrire simplement 0. et il pourrait aussi être plus clair pour les autres de lire dans votre code.

Source

2010-08-25 19:21:43 a1337q

cela peut aussi être utile ici: http : //stackoverflow.com/questions/551069/testing-pointers-for-validity-cc – a1337q

La valeur NULL, en C++, doit être 0. Tout compilateur qui traite les deux différemment n'est pas un compilateur C++. L'avantage de NULL est qu'il signifie que c'est supposé être une valeur de pointeur, mais l'inconvénient est que cela peut être trompeur. (Je suis vraiment impatient de 'nullptr' dans la prochaine norme C++.) –

test de pointeur valide en C++

Répondre

Questions connexes