Le code suivant ne compile pas. Il me mets "D& A::getD() >> est
prot=E9g=E9" alors que le compilo devrait "utiliser" la m=E9thode 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 =3D 0;
const D& d =3D a->getD();
}
Qu'en pensez-vous ? erreur du compilo ou ok pour le c++ ?
J'ai l'impression que la regle de pr=E9dilection de la m=E9thode const (ce
qui est effet mieux la plus part du temps) est syst=E9matique m=EAme si
cela aboutit =E0 une impasse. !?!
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Jean-Marc Bourguet
vicnet writes:
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
vicnet <osele@netcourrier.com> writes:
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
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
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.
On Mon, 26 Nov 2007 01:41:25 -0800 (PST), vicnet
<osele@netcourrier.com>:
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.
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.
