Re: Is it possible to call virtual method in derived class from base
class without declaring it abstract?
On Sep 28, 9:49 am, cpp4ever <n2xssvv.g02gfr12...@ntlworld.com> wrote:
On 09/28/2010 10:07 AM, Jaco Naude wrote:
Hi
Not sure if this is a stupid question, but here it goes:
Is it possible to call a virtual method in the derived class from a
base class? I know that the method can be made abstract but then the
whole class also becomes and abstract base class.
class BaseClass {
virtual bool method(bool call_derived) {
if (call_derived)
// I want to call method() in DerivedClass with=
out knowing
anything about it.
else
return false;
}
}
class DerivedClass : public BaseClass {
bool method() { return true; }
}
Thus when I do this in my main function:
BaseClass base;
base.method(true); // Should return true;
base.method(false); // Should return false;
Is this even possible at all? Or is the only way to do this by
declaring method() = 0 in the base class (like a normal interface
class).
Thanks,
Jaco
If you wish to ensure that the base class member function is called you
need to call the member function using a fully qualified name
Hence in DerivedClass you would need to call as follows
BaseClass::method(); // call BaseClass function
method(); // calls DerivedClass function
This will work even if it is called via a BaseClass pointer to a
DerivedClass object.
HTH
cpp4ever
Thanks for the answers. The problem is not a piece of code that does
not work, I'm trying to figure out if how something works in C++. I
created a proper small example which answers my question:
#include <QtCore/QCoreApplication>
#include <stdio.h>
class Base
{
protected:
virtual bool virtualBlah() const {
return false;
}
public:
bool blah() const {
return virtualBlah();
}
};
class Derived: public Base
{
protected:
virtual bool virtualBlah() const {
return true;
}
};
int main(int argc, char *argv[])
{
Base* base = new Base();
Derived* derived = new Derived();
if (base->blah())
printf("Call on base class instance: True\n");
else
printf("Call on base class instance: False\n");
Base* derived_base_ptr = reinterpret_cast<Base*> (derived);
if (derived_base_ptr->blah())
printf("Call on derived class instance: True\n");
else
printf("Call on derived class instance: True\n");
return a.exec();
}
The output of the program is:
Call on base class instance: False
Call on derived class instance: True
I always thought that if you call blah() on derived_base_ptr it will
call the base class implementation. To get to the derived class
implementation I thought you need a Derived*, unless you make the base
class an abstract base class.
Thank you for your help, it is appreciated.
Jaco