Re: virtual functions and dynamic binding

From:

"Jim Langston" <tazmaster@rocketmail.com>

Newsgroups:

comp.lang.c++

Date:

Fri, 23 Jun 2006 07:39:58 -0700

Message-ID:

<83Tmg.1068$lc5.862@fe07.lga>

"Mike Stevenson" <michael.stevenson@noaa.gov> wrote in message
news:e7esdt$p7g$1@gnus01.u.washington.edu...

Hi. I'm in the process of re-learning all the C++ I forgot from
college, and I'm starting to get into some virgin (or at least only a
couple times) territory. I have some questions about casting a pointer
from a base class to a derived class. For example:

class Base{
public:
Base() {}
virtual ~Base() {}
void func1(int);
virtual void func2(int);
protected:
int foo;
};
class Deriv : public Base{
public:
virtual void func2(int);
void func3(int);
protected:
int bar;
};

So let's say I make a pointer thus: Base *ptr = new Deriv;. As I
understand it (please correct me if I'm wrong), ptr will use Base::func1
and have access to foo. Since it's defined as virtual, it knows to use
Deriv::func2. What I'm confused about is that ptr will not be able to
use func3 or access bar, saying that class Base does not contain those
things. I guess what I don't understand is, why bother casting the
pointer do the derived type when it can't access all its members?
What's the advantage over using Deriv *ptr = new Deriv?

You could call func3 using this pointer if you cast it to a Deriv. Which is
where you would usually use RTTI to make sure it was actually pointing to a
Deriv first.

The reason to do this is so you could have a container of different types of
classes.

Make sure you enable RTTI in your compiler to get the following code to
work. Output is:
walking
woof woof
walking
meow!

#include <vector>
#include <iostream>
#include <string>

class animal
{
public:
    virtual ~animal() {}
    void walk() { std::cout << "walking" << std::endl; }
};

class dog: public animal
{
public:
    ~dog() {}
    void bark() { std::cout << "woof woof" << std::endl; }
};

class cat: public animal
{
public:
    ~cat() {}
    void meow() { std::cout << "meow!" << std::endl; }
};

int main()
{
    std::vector<animal*> Animals;

    Animals.push_back( new dog );
    Animals.push_back( new cat );

    for ( std::vector<animal*>::iterator it = Animals.begin(); it !=
Animals.end(); ++it )
    {
        (*it)->walk();

        dog* ThisDog = dynamic_cast< dog* >( (*it) );
        if ( ThisDog != NULL )
        {
            ThisDog->bark();
        }

        cat* ThisCat = dynamic_cast< cat* >( (*it) );
        if ( ThisCat != NULL )
        {
            ThisCat->meow();
        }
    }

    std::string wait;
    std::cin >> wait;

}