Re: Can someone explain this substitution?
Am 28.05.2011 10:34, schrieb Jeremy:
I think this problem maybe some part of the Liskov Substitution
Principle or Keonig lookup.
No, it isn't.
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;
};
Let me just throw in that such a class design is very sensitive to
ambiguity problems. If you really want to have the implicit conversion
function to int, why not having an explicit constructor?
// 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 is important: The base class provides a default argument.
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;
You can skip this theory, the typedef wouldn't change anything, because
typedefs are only other names for the exact same type. There exists no
"strong" typedef in C++.
class Base : public BaseIf
{
public:
void display(index1 x, bool y) {std::cout<< "display(int) :"<< x
<< std::endl; }
.... and the derived class does not. For static resolutions,
Base::display() hides BaseIf::display().
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);}
Here, the compiler considers only display(intLike) and
display(intLikeToo), because the third overload display(int, bool) can
only be called with two arguments, because default arguments are
resolved statically, not dynamically.
Some options to fix this:
- Add the same default arguments to Base::display
- Don't provide default arguments in BaseIf::display, instead provide a
non-virtual overload
void display(int x) { display(x, true); }
in BaseIf and make this overload visible in Base by adding:
using BaseIf::display;
};
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.
Actually the problem is due to the default function argument in
Base::display().
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.
This works, because this call will consider the default argument of
Base::display, because of the static resolution.
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.
See above why.
HTH & Greetings from Bremen,
Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]