Bit byte wrote:
Victor Bazarov wrote:
Bit byte wrote:
I have a class BaseApplication, from which I am deriving two
classes A and B.
In class BaseApplication, I have a virtual method as ff:
virtual void saveToDb(const char*);
So, you essentially have
class BaseApplication
{
public:
virtual void saveToDb(const char*);
};
, right? This is much easier to understand.
<snip>
I have this :
class BaseApplication
{
protected:
virtual void saveToDb(const char*);
};
class A: public BaseApplication {
public:
void saveToDb( const struct_for_a*) ;
This member does not override the 'saveToDb' you declared in the base
class. It _hides_ it. If you intended to override the function, you
need to keep its signature the same, IOW, the argument has to be the
same -- const char*. As soon as you changed it, the function is not
the overrider any longer.
};
//idea behind this is that B is a type of application that will
//need to persist many different types of data (polymorphically)
class B: public BaseApplication {
public:
void saveToDb( const struct relevant_for_b*) ;
void saveToDb( const struct another_struct_for_b*) ;
void saveToDb( const struct yet_another_for_b*) ;
};
I want to know if I can do this. I believe I have done something
similar to this many moons ago, but I don't quite remember.
You can do this. It has nothing to do with polymorphism, but it is
perfectly legal.
#include <iostream>
struct A {
virtual void foo(const char*) { std::cout << "A::foo()\n"; }
};
struct B : A {
void foo(int) { std::cout << "B::foo()\n"; }
};
struct OK : A {
void foo(const char*) { std::cout << "OK::foo()\n"; }
};
int main() {
B b;
OK ok;
A *pa = &b;
pa->foo("abc"); // base class function is called
pa = &ok;
pa->foo("def"); // derived class function is called
}
V
Thanks for the clarification Victor. I'll have to refresh my memory on