wrote:
> Dear All,
> According to OOPs , a base class pointer can to point to derived class
> object....call this as fact1
> But somehow I am not comfortable while understanding this concept.
> The explanaition to the fact1 is given as since the derived object
> always consists of the base part , the base class pointer will always
> point to the base part in the derived object unless otherwise the
> function in the base class are declared as virtual and are overrided in
> the derived class.
> My confusion is, since the derived class always consists of the base
> class part in it,it should be more logical to think that the pointer to
> the derived class can store the address of the base class object as it
> will be always carrying the base class related services and data with
> it.
> This confusion gives me lot of headech while studying the COM and other
> advanced concept . will someone please give me any good explaination or
> justification of where my thinking process is going wrong(straying??)?.
> I will be very grateful to him..
class A
{
public:
void f();
};
class B : public A
{
public:
void g();
};
Now, objects of type A can call f() and objects of type B can call
either f() or g().
int main()
{
A a;
B b;
a.f(); // ok
a.g(); // error
b.f(); // ok
b.g(); //ok
A *pa = &b; // ok
B *pb = &a; // that's illegal, but what if
pa->f(); // ok
pa->g(); // error
pb->f(); // ok
pb->g(); // ok !!! pb actually points to an A and As don't
// have g() !
}
By having pb point to a A, the compiler accepted the call to g(), even
if the object we are pointing at (actually a A) does not contain such
member function. That's because the function calls are checked on the
static type of the object (which is A*), not on the dynamic type (which
is B*).
You can implicitly cast pointers to a base class, because the compiler
is 100% sure the object pointed to *is a* base class (it is perhaps more
than that, such as a B or a C, but it is at least a base class). You
can not implicitly cast pointers to a derived class, because the
compiler cannot check if the object *is a* derived class.
void f(B *a)
{
// does a really point to a B?
}
void g1()
{
A a;
f(&a); // no it does not, so that must be illegal
}
void g2()
{
B b;
f(&b); // yes it does, so that's legal
}
There are (unfortunately) some circumstances where *you* know for sure
an A* is a B*, so you are able to do the cast explicitly. Using
dynamic_cast over static_cast can make things a bit more safer.
Jonathan
Similar Threads
