Re: Need some information about function hiding
The thing you're missing is the steps made while calling a memberfunction:
1. Look up the name. This starts in the the static type of the object and
then continues in baseclasses.
2. Once the name is found, the compiler performs overload resolution
depending on the parameters. Note that the compiler will _not_ go back to
step 1 if no suitable overload is found.
3. If the resulting function is virtual, do dynamic dispatch according to
the dynamic type of the object.
abhijeet wrote:
class base
{
public:
virtual void foo(int i) {printf("inside base\n");};
};
class derived : public base
{
public:
virtual void foo(A &i) {printf("inside derived\n");};
};
Note: derived::foo and base::foo are overloads, derived::foo does not
override base::foo!
base *ptr = new derived();
Note the distinction between the static and dynamic type of *ptr, the
static type is base and the dynamic type is derived. This is important for
dynamic dispatch of virtual functions.
ptr->foo(1);
The static type is base, so looking up the name foo in that class yields
the only overload base::foo. Then, the parameter is an int, so it selects
the base::foo(int) overload (actually it's not really an overloaded
function, it just selects the only one that is there). Then, since the
function is virtual, do a dynamic dispatch. Since the function isn't
overridden in derived, it still calls the base function.
"test.cpp", line 14: Warning: derived::foo hides the virtual function
base::foo(int).
Interestingly, this is irrelevant, since you never lookup foo in a derived
object, the only lookup is in the base object (see step 1, lookup in the
static type).
a.out
inside base
I understand that when I replace the argument type for a function in
derived type, original defn gets hidden.
Errrm, almost. The point is that during step 1, the name is hidden. This
has nothing to do with the fact that you changed the argument type, a
virtual or nonvirtual override would have done the same, or even adding a
member variable instead of a function.
Only thing I find really interesting is why in case we have types
which can not be converted by promoting (like I can promote int to
float) definitions are still hidden.
I'm not sure what your question is here. Overriding a virtual function
requires the exact same function signature (arguments and return type).
The only exception is covariant return types, but you don't have those
here.
Also, with default rules I am having hard time explaining execution
which is above on sun solaris CC.
Two things:
1. It is the name lookup which will never find the base::foo when done on
a derived object. That's what the warning is about. However, the function
in the base class still exists and can be called, too. In your case, it's
via a pointer-to-base, which does the name lookup (step 1) on the
baseclass.
2. Since you don't override the function in the derived class, your call
(which does a dynamic dispatch in step 3) will still call the version from
the baseclass.
HTH
Uli
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]