2010-12-06 6 views
1

Considérons le code suivant:C++ opérateur d'affectation résolution

struct A 
{ 
    void foo(const char *) { cout << __PRETTY_FUNCTION__ << endl; } 
    A & operator = (const A & ) { cout << __PRETTY_FUNCTION__ << endl; return * this; } 
}; 


struct B : public A 
{ 
    void foo(const char *) { cout << __PRETTY_FUNCTION__ << endl; } 
    A & operator = (const A & other) { cout << __PRETTY_FUNCTION__ << endl; return * this; } 
}; 

Puis, quand nous appelons ces membres:

B b; 

b.foo("hehe"); 
b = b; 

sera imprimé:

void B::foo(const char *) 
A& A::operator=(const A&) 

Question: pourquoi B :: foo cache A :: foo, mais B :: operator = non?

Répondre

8

Ce que vous voyez n'est pas du tout un problème caché. Vous n'avez pas créé d'opérateur d'affectation pour affecter B à B, le compilateur en a donc créé un pour vous. Celui créé par le compilateur appelle l'opérateur d'assignation de A.

Par conséquent, si votre question "Question: pourquoi B :: foo cache A :: foo, mais B :: operator = ne fait pas?" devrait être lu "Comment l'opérateur est différent d'une fonction ordinaire", la différence est que le compilateur vous en fournira un si vous n'écrivez pas le vôtre.

+0

Ok, à ma connaissance, le compilateur génère le code suivant pour B: B & operator = (const B & b) {A :: operator = (b); return * this; } Mais si nous avons un "A :: operator =" virtuel, alors "B :: operator =" devrait être invoqué, car il écrase "A :: operator =". Mais ce n'est pas le cas. – drinian

+1

la virtualité n'a pas d'importance ici. Une copie générée par le compilateur appelle toujours l'implémentation de la classe de base. Cela dit, avoir operator = virtual est rarement logique. Cf. http://icu-project.org/docs/papers/cpp_report/the_assignment_operator_revisited.html – Suma