Overloading a virtual function with non-virtual: no-go?

[Joe P]

Hi,
just wondering if there is something in the C++ language standard that
forbids the following construct:

class Base {
public:
virtual int GetSomething( int x, int y );
int GetSomething( double z );
};

#include "Base.h"
class Derived: public Base {
public:
virtual int GetSomething( int x, int y );
};

.....
#include "Derived.h"
{
Derived *obj = new Derived();
obj->GetSomething( 2.0 );
}

Neither gcc nor Microsoft's compiler liked this, indicating that the
double 2.0 could not be cast to an int or that there is no matching
function. Is this forbidden in the standard or are the compilers not
meeting standard?

A workaround is to declare GetSomething( double ) as virtual also, but
because this method has no need to be virtual, each derived method just
calls the base method. Another alternative is to rename the method. In
any case, it seems unnecessary except that the compilers refuse to work
with the code as written.

[Maxim Yegorushkin]

On Sat, 18 Jun 2005 22:41:39 +0400, Joe P <[e-mail]> wrote:

[]

Neither gcc nor Microsoft's compiler liked this, indicating that the
double 2.0 could not be cast to an int or that there is no matching
function. Is this forbidden in the standard or are the compilers not
meeting standard?

Please refer to
http://new-brunswick.net/workshop/c+....html#faq-23.6

--
Maxim Yegorushkin

[Gianni Mariani]

Joe P wrote:

Hi,
just wondering if there is something in the C++ language standard that
forbids the following construct:

class Base {
public:
virtual int GetSomething( int x, int y );
int GetSomething( double z );
};

#include "Base.h"
class Derived: public Base {
public:
virtual int GetSomething( int x, int y );
};

....
#include "Derived.h"
{
Derived *obj = new Derived();
obj->GetSomething( 2.0 );
}

Neither gcc nor Microsoft's compiler liked this, indicating that the
double 2.0 could not be cast to an int or that there is no matching
function. Is this forbidden in the standard or are the compilers not
meeting standard?
The compilers are applying the standard correctly. Because you have
defined a GetSomething function in Derived, it masks any other
GetSomething functions from parent classes. If you want to use one of
the masked functions, you can use the using keyword or use is by
specifying the scope.

class Base {
public:
virtual int GetSomething( int x, int y ) { return 0; }
int GetSomething( double z ) { return 0; }
};

class Derived: public Base {
public:
using Base::GetSomething;
virtual int GetSomething( int x, int y ) { return 1; }
};

class Derived1: public Base {
public:
virtual int GetSomething( int x, int y ) { return 1; }

};

int main()
{
Derived *obj = new Derived();
obj->GetSomething( 2.0 );

Derived1 *obj1 = new Derived1();
obj1->Base::GetSomething( 2.0 );
obj1->GetSomething( 2.0 ); // error
}

A workaround is to declare GetSomething( double ) as virtual also, but
because this method has no need to be virtual, each derived method just
calls the base method. Another alternative is to rename the method. In
any case, it seems unnecessary except that the compilers refuse to work
with the code as written.

You could also simply write a wrapper.

class Derived: public Base {
public:
virtual int GetSomething( int x, int y ) { return 1; }
int GetSomething( double z ) { return Base::GetSomething( z ); }
};

[Joe P]

On Sat, 18 Jun 2005 18:30:24 -0700, Gianni Mariani wrote:

You could also simply write a wrapper.

class Derived: public Base {
public:
virtual int GetSomething( int x, int y ) { return 1; } int
GetSomething( double z ) { return Base::GetSomething( z ); }
};

Thanks, this seems the cleanest solution.