2017-10-19 40 views
-1

Je voulais savoir si je pouvais vérifier qu'une référence était invalide. Je crois que je peux, mais je ne suis pas sûr. À cet égard, je voudrais aussi savoir si dans le cas suivant, je suis « déréférencement » le pointeur:Puis-je vérifier les références par rapport à une valeur nulle ou un certain type de valeur?

struct Texture { int width; }; 

void useTexture(Texture& texture) 
{ 
    int a = texture.width; 
    //Exception thrown: read access violation. 
texture was nullptr. 
// When I hover the mouse over the argument it says "struct at null" 
} 

int main() 
{ 
    Texture* obj = nullptr; 
    useTexture(*obj); // This is using the dereference operator, 
         // but no exception is thrown here. 
} 

L'exception ne se produit que dans la fonction useTexture(). Dans ce cas, en passant l'argument * obj à la fonction, il ne lit pas les données de cet emplacement, il donne simplement l'adresse à la référence, je suppose que pas de manière différente que ce qui se passerait lors du passage d'un pointeur. Donc même si j'ai utilisé l'opérateur de déréférencement, est-ce qu'il a effectivement déréférencé le pointeur? Je ne pense pas.

Aussi, je voudrais savoir s'il existe un moyen de vérifier la fonction useTexture() si la référence est valide. Dans le débogueur lorsque je survole l'argument, il dit que la structure est à null, et quand il lance l'exception, il dit que la texture est nullptr. Je suppose qu'il dit nullptr parce que son adresse est 0x00, parce que la texture n'est pas un pointeur du tout, mais une référence.

De même, si je fais:

Texture* obj = (Texture*)0x80; 
useTexture(*obj); 

Au lieu de dire « struct à nulle », il dit qu'il ne peut pas lire les données, et en jetant l'exception, il dit: « l'accès mémoire invalide à 0x80 ». C'est ce que je comprends.

Ce que je voulais faire était d'avoir une vérification de sécurité dans la fonction qui vérifie si elle est valide. En rappelant que les gens disent que les références ne peuvent pas être nulles, j'ai pensé que je devrais changer la fonction pour prendre un pointeur, et je pourrais vérifier par rapport à une valeur de pointeur, comme nullptr. Mais d'après ce que j'ai vu, les références ont aussi des adresses, et peuvent être nulles. Existe-t-il un moyen de vérifier si la référence est valide sans la remplacer par un argument de pointeur? Je suppose que la question de déréférencement est une question distincte, mais je ne voulais pas poser deux questions.

Edit: Je viens de tester, et je pensais que je pouvais faire quelque chose comme:

if ((Texture*)&texture == nullptr) return; 

Au lieu de vérifier pour nullptr sur le site d'appel.

Répondre

1

Faire quelque chose comme ceci:

A * a = nullptr; 
A b = * a; 

est non défini en C++. Il est également indéfini même si vous ne créez pas la variable nommée, car le compilateur peut décider de créer un nom sans titre en déréférenciant a. Donc, cette déclaration:

* a; 

est également indéfini.

+0

Dans le premier cas, il lit l'adresse du pointeur. Je comprends que c'est un non-go. Lorsque je passe à une référence lorsque j'utilise l'opérateur de déréférencement, je doute qu'il soit déréférencé parce qu'il envoie simplement sa valeur d'adresse, comme il le fait pour un autre pointeur. – Zebrafish

+0

Les références ne sont pas des pointeurs. –

+0

Je sais, je dis juste que quand je fais callfunction (* obj) je doute qu'il fasse du déréférencement du tout, la référence prend l'adresse de l'objet, c'est tout, non? – Zebrafish