Inheritance of overloaded functions

[Jean-Christophe MATHAE]

Hello,

To ease my frustration, could some give me an example that justifies why
They choose to invalidate the following piece of code:
class filter
{
public:
virtual void Put (const float Sample) = 0;
virtual float Get() const = 0;
virtual float Get (const float Sample)
{ Put (Sample); return (Get()); }
};

class filterDSP : public filter
{
public:
void Put (const float Sample);
float Get() const;
};

filerDSP dsp;

voif (float f)
{
return (dsp.Get (f)); // ERROR!!! WRONG
NUMBER OF ARGUMENTS
}
One could argue that this is due to r.13.1 But I need more ;-)

Thank you.

[Victor Bazarov]

Jean-Christophe MATHAE wrote:

To ease my frustration, could some give me an example that justifies why
They choose to invalidate the following piece of code:
class filter
{
public:
virtual void Put (const float Sample) = 0;
virtual float Get() const = 0;
virtual float Get (const float Sample)
{ Put (Sample); return (Get()); }
};

class filterDSP : public filter
{
public:
void Put (const float Sample);
float Get() const;
};

filerDSP dsp;

voif (float f) ^^^^^^^^^^^^^^
There is a syntax error somewhere in this line...
{
return (dsp.Get (f)); // ERROR!!! WRONG
NUMBER OF ARGUMENTS
The 'filterDSP::Get()' _hides_ the 'filter::Get(float)' function.
}
One could argue that this is due to r.13.1 But I need more ;-)

I guess that one could, but I wouldn't argue that. You have a very
simple case of *name hiding*.

V

[Joe P]

On Mon, 20 Jun 2005 13:08:51 -0400, Victor Bazarov wrote:

The 'filterDSP::Get()' _hides_ the 'filter::Get(float)' function.

}

One could argue that this is due to r.13.1 But I need more ;-)

I guess that one could, but I wouldn't argue that. You have a very simple
case of *name hiding*.

Where does this name hiding feature arise and why? Other languages don't
seem to need it.

[Pete Becker]

Joe P wrote:

Where does this name hiding feature arise and why? Other languages don't
seem to need it.

struct Base
{
};

struct Derived : Base
{
void f(double);
};

void test()
{
Derived d;
d.f(3);
}

So far, so good. Now imagine Base is defined in some third party
library, and in a maintenance release they change it:

stuct Base
{
void f(int);
};

If Base::f is considered in the possible matches for the call d.f(3) it
wins, and you've got a change in behavior.

--

Pete Becker
Dinkumware, Ltd. (http://www.dinkumware.com)