Re: Can someone explain this substitution?

I think this problem maybe some part of the Liskov Substitution
Principle or Keonig lookup. Below is some code that demonstrates it.

#include<iostream>

// A class that will implicitly cast to an int
class intLike
{
public:
    intLike(int x): x_m (x){}
    operator int() { return x_m; }
private:
     int x_m;
};

// Another class that will implicitly cast to an int
class intLikeToo
{
public:
    intLikeToo(int x): x_m (x){}
    operator int() { return x_m; }
private:
     int x_m;
};
class BaseIf
{
public:
     virtual void display(int x, bool y=true) = 0;
     virtual void display (intLike x) = 0;
     virtual void display (intLikeToo x) = 0;

     //virtual void fun()=0;
};

// Note: just a typedef on int just to see if that made any
// difference on behaviour
typedef int index1;

class Base : public BaseIf
{
public:
     void display(index1 x, bool y) {std::cout<< "display(int) :"<< x
<< std::endl; }
     void display (intLike x) {std::cout<< "display(intLike) :"<< x
<< std::endl; }
     void display (intLikeToo x) {std::cout<< "display(intLikeToo) :"
<< x<< std::endl; }

     // This method will result in an ambigous function call
     // void fun(){ display(2);}
};
int main()
{
    BaseIf * b = new Base;

         b->display(2);

         // This call will result in an ambiguous function call
         //b->fun();

    return 0;
}

The problem I am having is this, the abstract class declares an
overloaded method display. The first display(int) simply takes an
int, the other two purposefully take an argument that can be
implicitly promoted from and int.

Step 1: In main, I get a pointer to a Base object. I then make a call
to display(int). Since there is a display(int) in the class it will
make the correct call to display(int). Everything compiles and runs as
expected.

Step 2: If I comment out display(int) so that there are only calls to
display(intLike) and display(intLikeToo) then of course, I get a
compile error in main because the call to display(2) is ambiguous.
This is also expected.

Step 3: This is where I am having a problem, if I uncomment
display(int) and add another method to Base called fun(), and fun()
simply calls display(2), I again receive the ambiguous overloaded
method error.

So why is it ok to call display(2) from main(), but I end up getting a
compile error if I call display(2) from within the class itself? I
would have expected that if Step 1 compiled fine, then Step 3 would
have also compiled fine.