On Nov 14, 1:22*pm, ".rhavin grobert" <cl...@yahoo.dewrote:
On 14 Nov., 19:11, Victor Bazarov <v.Abaza...@comAcast.netwrote:
.rhavin grobert wrote:
guess you have ....
class Grandbase {
public:
* *virtual int foo();
};
class Base: public Grandbase {
* */* no foo() specified here */
};
class Derived, public Base {
public:
* *virtual int foo();
};
my compiler gives no errors, ..but ... is it safe?
Define "safe".
does a...
void callfoo(Grandbase* b)
{
* b->foo();
};
Derived d;
callfoo(d);
always call Derived::foo() ?
yes, and callfoo() can also be a member function of Grandbase
It'll call the appropriate virtual foo()
with respect of the type of the object calling it.
Thats still the case even if foo() is private.
#include <iostream>
class Grandbase
{
virtual int foo()
{
std::cout << "GrandBase::foo()\n";
return 0;
}
public:
int callfoo() { return foo(); }
};
class Base : public Grandbase {
};
class Derived : public Base
{
int foo()
{
std::cout << "Derived::foo()\n";
return 0;
}
};
int main()
{
Base b;
Derived d;
b.callfoo();
d.callfoo();
}
/*
GrandBase::foo()
Derived::foo()
*/
I see you passing pointers around, prefer references to constant.
Why?
If you allocate and deallocate using Grandbase* pointers, you'll get
memory leaks because your Grandbase class doesn't have a virtual
d~tor.
What you can't do is declare foo() in Grandbase pure virtual and then
attempt to create an instance of Grandbase or Base.
