Acces resteint (protected) et const&

Le
vicnet
Bonjour,

Le code suivant ne compile pas. Il me mets "D& A::getD() >> est
protégé" alors que le compilo devrait "utiliser" la méthode publique,
non ?

class D {
public:
};

class A {
public:
const D& getD() const { return _d; }
protected:
D& getD() { return _d; }
private:
D _d;
};

void f() {
A* a = 0;
const D& d = a->getD();
}

Qu'en pensez-vous ? erreur du compilo ou ok pour le c++ ?

J'ai l'impression que la regle de prédilection de la méthode const (ce
qui est effet mieux la plus part du temps) est systématique même si
cela aboutit à une impasse. !?!

Merci
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Jean-Marc Bourguet
Le #313322
vicnet
Bonjour,

Le code suivant ne compile pas. Il me mets "D& A::getD() >> est
protégé" alors que le compilo devrait "utiliser" la méthode publique,
non ?


Non. Les deux points à savoir:
- le contrôle d'accès est fait *après* résolution de la surcharge.
- les membres const ne sont préférés à leur version non const que quand
l'objet est const, ce qui n'est pas le cas ici (a n'est pas const).

A+

--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org

Fabien LE LEZ
Le #313321
On Mon, 26 Nov 2007 01:41:25 -0800 (PST), vicnet

class A {
public:
const D& getD() const { return _d; }
protected:
D& getD() { return _d; }


Attention, "protected" et "private" peuvent empêcher l'accès, mais ne
modifient en rien la visibilité.

(En fait, la règle de base est en gros : si tu as un programme qui
compile, remplacer "protected" et "private" par "public" ne modifiera
en rien son fonctionnement.)

void f() {
A* a = 0;


Ici *a est non-const, donc c'est la fonction membre non-const qui est
appelée.

J'ai l'impression que la regle de prédilection de la méthode const (ce
qui est effet mieux la plus part du temps) est systématique même si
cela aboutit à une impasse. !?!


Je ne suis pas sûr de comprendre ce que tu racontes.
Il faut se représenter une fonction membre comme une fonction qui
prend this en paramètre.

Ainsi, si tu écris :

class A
{
public:
void f() const;
void f();
void g() const;
}

c'est un peu comme écrire :

void f (A const*);
void f (A*);
void g (A const*);

Si tu déclares
A* a;
et que tu appelles f(a), puisque a est un A*, la fonction "f(A*)"
convient directement, et aucune autre fonction n'est candidate.

Si maintenant tu appelles g(a), a ne convient pas directement, donc il
y a conversion implicite en un "A const*", puis g(A const*) est
appelée.

Publicité
Poster une réponse
Anonyme