une question sur la priorité de l ' « adresse » des opérateurs de C et « résolution de portée »

Question

Bonjour J'ai ce code avec une erreur du compilateur (erreur de Microsoft Visual Studio 2008):

class B 
{ 
protected: 
int b; 
}; 

class A : public B 
{ 
public: 
void foo(){ &B::b; }// error C2248: 'B::b' : cannot access protected member declared in class 'B' 
}; 

alors que ce code est sans erreur:

class B 
{ 
protected: 
int b; 
}; 

class A : public B 
{ 
public: 
void foo(){ &(B::b); } 
}; 

les deux extraits me semble équivalent basé sur ma connaissance de la priorité des opérateurs, car :: a une priorité plus élevée que & (voir par exemple le tableau 2, à la page 137 du « COMBAT JOINT STRIKE FIGHTER NORMES DE CODAGE C++ DU VEHICULE AERIEN POUR LE DEVELOPPEMENT DU SYSTEME A Mais ils sont différents ... Je pense que c'est quelque chose en rapport avec "pointer-to-data-member" mais je ne sais pas comment ça va avec la priorité des opérateurs.

Une explication?

Merci, Alessandro

Answer 1

Dans le premier cas, vous prenez l'adresse de pointeur à membre B::b. Comme un tel pointeur n'est pas un membre du parent de A mais un objet séparé, il ne peut pas y accéder via le mécanisme protégé.

Dans le second cas où cela fonctionne vous demandez l'adresse du de b, instance spécifique qualification avec sa classe de base de telle sorte que dans le cas d'héritage multiple le compilateur savoir quelle classe de base que vous voulez dire . Dans ce contexte, l'attribut protégé est visible.

Notez que cette compile:

class B 
{ 
protected: 
int b; 
}; 

class A : public B 
{ 
public: 
void foo(){ &A::b; } // Note here &A:: instead of &B:: 
}; 

À titre d'exemple ajouté qu'il ne fonctionne pas pour la même raison que le code suivant (je l'espère plus familier) ne fonctionne pas:

class B 
{ 
protected: 
int b; 
}; 

class A : public B 
{ 
public: 
void foo(const B* b_obj) { b_obj->b; } 
}; 

Answer 2

La différence entre les deux instructions devient plus évidente lorsque vous essayez de renvoyer la valeur:

int*  foo() { return &(B::b);} // This is a pointer to an int 


int A::* foo() { return &B::b; } // This is a pointer to a member of type int 

Qu'est-ce que vous voulez faire est l'accès via l'Objet: A partir de A, vous êtes autorisé

int A::* foo() { return &A::b; } // This is a pointer to a member of type int 

pour y accéder.
L'accès via B comme ça est l'accès de l'extérieur et déclenche ainsi les spécificateurs d'accès.

Answer 3

Ceci est juste une supplémentation.
§5.3.1/2 dit:

Le résultat de l'opérateur & unaire un pointeur vers son opérande. L'opérande doit être une lvalue ou un ID qualifié. Dans le premier cas, si le type de l'expression est « T », le type du résultat est « pointeur vers T. » ...
Pour un -id qualifié, ...Si le membre est un membre non-statique de la classe C de type T , le type du résultat est « pointeur à un membre de la classe C de type T. »

Selon §5.1/7, B::b relève du cas de l'identificateur qualifié, mais pas du (B::b). Ainsi, le compilateur l'interprète comme une valeur lvalue.