Virtual inheritance / Polymorphism

Question

So I'm looking at some weird cases of Polymorhpism and ambiguity. And there's one case which I cannot understand. I don't understand why the last line of the code below act this way.

#include <stdio.h>
#include <iostream>

class Article
{
public :
    virtual bool compare(Article *a) { std::cout << "ACA" << std::endl;}; // ACA
};

 class Clothe : public Article
 {
    public :
        bool compare (Clothe *c) { std::cout << "CCC" << std::endl;}; // CCC
        bool compare (Article *a) { std::cout << "CCA" << std::endl;}; // CCA
};



int main()
{
Article *pta1 = new Article;
Article *pta2 = new Clothe;
Clothe *ptv1 = new Clothe;

pta1->compare(pta2); // print ACA
pta2->compare(pta1); // print CCA
pta2->compare(pta2); // print CCA because compiler needs to explore pta2 to determine which compare to use.
                     // pta2 is instanced as a Clothe, so one of Clothe's compare will be called. 
                     // And judging by its declaration pta2 is an Article (even thought it's instanced as a Clothe),
                     // so it will Call Clothe::Compare(Article*). I'm OK with this 

pta2->compare(ptv1); // print CCA ??? WHY , pta2 is explored, thus it's type is determined to be of type Clothe.
                     // And ptv1 is declared as a Clothe, so it should call Clothe::compare(Clothe* c)
                     // should print CCC, shouldn't it ?
}

I'm lost. I don't understand how g++ resolve the ambiguity that way. Any help / explanation would be nice. Thanks for reading, and even more thanks to those who answer.

PS : I know compare should return bool, but it's not really important here.

EDIT : typo slided during my on-the-fly translation of variable names, names were originally in french sorry for that. It's fixed now

Check your code. Looks like you mistyped some `Clothe::compare` definition — Lol4t0, Feb 21 '16 at 13:48
Yes indeed was translating variable names on the fly on satckoverflow. Fixed now thanks for noticing that. — aramir, Feb 21 '16 at 13:50
my question is why isn't bool Clothe::compare(Clothe * c) called for pta2->compare(ptv1); — aramir, Feb 21 '16 at 13:55
*"typo slided during my on-the-fly translation of variable names, names were originally in french sorry for that."* - It is of course a good idea to translate names into English first. However, you skipped one important step: **Compiling** the translated code and making sure that there are no errors **before** posting it here. — Christian Hackl, Feb 21 '16 at 14:07

Pixelchemist · Accepted Answer · 2016-02-21T14:11:25.750

This line

pta2->compare(ptv1);

prints CCA because there is only a virtual function bool compare(Article *a) in the base class.

Your assumption about pta2 is wrong.

pta2 is explored, thus it's type is determined to be of type Clothe.

Which is not the case. The type of pta2 is Article * and nothing else. It only points to a Clothe object and it is therefore possible to call functions of Clothe through it, if (and only if) they are present and virtual and the base class and overrided (with the same Signature!) in the derived class.

Simply speaking:

The compiler can only "find" overloads in the derived class which are present and virtual in the base class if the call is performed via base class pointer.

What is happening here:

pta2 is a pointer to Article. Thus, when calling compare, the different possibilities of compare functions in Article are considered.
The only match is bool Article::compare (Article *a).
Now the compiler finds compare in Article to be virtual and uses some internal mechanism to make a virtual call through the 'vtable' of the object.
As Clothe overrides bool compare (Article *a), the overrided function is called.

The Base class knows nothing about bool compare (Clothe *c) since it does not know anything about Clothe and therefore the output is not CCV.

Ok thanks a lot, I got it all wrong. Thanks for clarifying it for me. I was thinking backward, children->mother when in reality, it goes more like mother->children. — aramir, Feb 21 '16 at 14:09
Re reading this, but why does g++ allow the usage of Article::Clothe::compare(article *a) when the parameter is ptv1 / Clothe? — aramir, Feb 21 '16 at 15:36
@aramir: Because an implicit pointer conversion is allowed to convert a derived class pointer to an (unambiguous) base class pointer. — Pixelchemist, Feb 21 '16 at 15:41

Virtual inheritance / Polymorphism

1 Answers1