Re: Can someone explain this substitution?
On 05/28/2011 10:34 AM, Jeremy wrote:
I think this problem maybe some part of the Liskov Substitution
Principle or Keonig lookup. Below is some code that demonstrates it.
I do not see why you hold Koenig responsible - no fingerprints at all.
#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;
This default kicks in when you are referring to BaseIf.
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; }
Bad thing: changing defaults. This kicks in when you are referring to Base.
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);}
You are referring to Base, not BaseIf. Out of three overloads the first
gets kicked out (not two parameters).
I haven't tried, but maybe ((BaseIf*)this)->display(2); - that is if you
really need to change defaults. The other two are next in line - conversion.
};
int main()
{
BaseIf * b = new Base;
b->display(2);
Try: Base* b2 = new Base; b2->display(2). Will refer to Base, not BaseIf.
// 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).
You have a pointer of type BaseIf*, it just happens to be a Base instance.
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.
Call via BaseIf and you'll be happy, or do not change defaults when
overriding.
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.
Edek
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]