function name hiding

[bb]

Hi,

Why overriding "virtual void f(std::string)" as follows hides the "non-
virtual void f(int)" ?

compilation error C2664: 'D::f' : cannot convert parameter 1 from
'int' to 'std::string'

I know it will work if I bring it to the scope by B::f(). I just would
like to know why does it hide just because am implementing a virtual
method.

Thanks in advance.

------ code starts -------

class B {
public:
void f(int i) {
std::cout << "B::f(int)" << std::endl;
}
virtual void f(std::string s) {
std::cout << "virtual B::f(std::string)" << std::endl;
}
};

class D : public B {
public:
void f(std::string s) {
std::cout << "D::f(std::string)" << std::endl;
}
void g() {
std::cout << "D::g()" << std::endl;
f(10); // works if I make it B::f(10)
}
};

------ code ends -------

[Neelesh Bodas]

On Aug 28, 2:41 pm, bb <[e-mail]:

Hi,

Why overriding "virtual void f(std::string)" as follows hides the "non-
virtual void f(int)" ?

class B {
public:
void f(int i) {
std::cout << "B::f(int)" << std::endl;
}
virtual void f(std::string s) {
std::cout << "virtual B::f(std::string)" << std::endl;
}

};

class D : public B {
public:
void f(std::string s) {
std::cout << "D::f(std::string)" << std::endl;
}
void g() {
std::cout << "D::g()" << std::endl;
f(10); // works if I make it B::f(10)
}

};

Because C++ standard says so.
10.2(2): A member name f in one subobject B hides a member name f in a
subobject A if A is a base class subobject of B. Any declarations that
are so hidden are eliminated from consideration.

Thus D::f(std::string) will hide B::f(int i) as well as
B::f(std::string s)

-N

[Reetesh Mukul]

On Aug 28, 3:20 pm, Neelesh Bodas <[e-mail]:

On Aug 28, 2:41 pm, bb <[e-mail]:

Hi,

Why overriding "virtual void f(std::string)" as follows hides the "non-
virtual void f(int)" ?

class B {
public:
void f(int i) {
std::cout << "B::f(int)" << std::endl;
}
virtual void f(std::string s) {
std::cout << "virtual B::f(std::string)" << std::endl;
}

};

class D : public B {
public:
void f(std::string s) {
std::cout << "D::f(std::string)" << std::endl;
}
void g() {
std::cout << "D::g()" << std::endl;
f(10); // works if I make it B::f(10)
}

};

Because C++ standard says so.
10.2(2): A member name f in one subobject B hides a member name f in a
subobject A if A is a base class subobject of B. Any declarations that
are so hidden are eliminated from consideration.

Thus D::f(std::string) will hide B::f(int i) as well as
B::f(std::string s)

-N

Along with the answer of Neelesh, you will like to see this page by
Bjarne Stroustroup:-
http://www.research.att.com/~bs/bs_f...verloadderived

Regards,
RM

[Pete Becker]

On 2007-08-28 05:41:57 -0400, bb <mu**********@gmail.comsaid:

>
Why overriding "virtual void f(std::string)" as follows hides the "non-
virtual void f(int)" ?

Overloading applies to names defined in the same scope. B::f and D::f
are defined in different scopes, so overloading is not applicable. That
provides a bit of protection from surprises during maintenance:

class B
{
};

class D : public B
{
public:
void f(double);
};

D d;
d.f(3);

Now suppose that during maintenance (perhaps installing a new version
of a library that provides the base class B) a new member is added to B:

class B
{
public:
void f(int);
};

If overloading wasn't limited to scopes, the behavior of d.f(3) would
change: it would call B::f instead of D::f. That would almost certainly
be wrong: the designer of B typically has no knowledge of what D is
doing, and B::f, while appropriate for use in B, wouldn't do anything
sensible for a D object.

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)