Loosing inherted data members. Trying Downcasting.

I am having trouble with I believe Downcasting.

There are two classes, a base class and an inherited class.

What I'm trying to do is store refernces to the two mixed classes within a single list

but when I push the reference to the object into the list, it looses it's non base class datamembers

I believe I need to Downcast, and so am trying to , but am still loosing the datamembers

Base Class:

Code:

---

class Vehicle
{
public:       
        Vehicle(int publicmpg = 0);

protected:
        int privatempg; 
};

Vehicle::Vehicle(int publicmpg)
{
        privatempg = publicmpg;       
}

---

Derivied Class:

Code:

---

class SportsCar : public Vehicle
{
public:
        SportsCar(int publicsixspeed = 0, int publicmpg = 0);

protected:
        int protectedsixspeed;
};

SportsCar::SportsCar(int publicsixspeed, int publicmpg) : Vehicle(publicmpg)
{
        protectedsixspeed = publicsixspeed;
}

---

main:

Code:

---

#include <iostream>
#include <list>
#include "Vehicle.h"

using namespace std;

int main()
{
        list<Vehicle> listname;

        int publicmpg = 0;
        int publicsixspeed = 0;
        int publicelectricroof = 0;

        SportsCar node(publicmpg, publicsixspeed);

        SportsCar *ptrToSportsCar;

        //attempting to correct the problem by Downcasting
        ptrToSportsCar = dynamic_cast<Vehicle*>(&node);

        //Push the SportsCar object onto the list, but inhertited datamember 'protectedsixspeed' is lost.
        listname.push_back( *ptrToSportsCar );

        system ("PAUSE");
        return 1;
}

---

Visual studio reports:

Quote:

---

cannot convert from 'Vehicle *' to 'SportsCar *'

---

I've just moved house and stuck on dialup, so have read the book I have
on the subject, and this is what I have come up with after reading it.

It compiles and is what I can gather from my book
as to be correct, but seems is not right.

Could anyone provide a solution at all?

It would be most appreciated.

Thank you !

The problem is that you are storing Vehicle objects in the std::list. Consequently, trying to store SportsCar objects in the std::list results in type slicing, where the objected stored really is just a Vehicle, not a SportsCar, hence attempts to cast it back to a SportsCar will fail.

Polymorphism in C++ works via pointers and references, so the solution is to use a container of pointers instead. This can mean using a std::list<Vehicle*>, a std::list<std::tr1::shared_ptr<Vehicle> >, or if you have access to Boost, a boost::ptr_list<Vehicle>.

Incidentally, it probably makes no sense to actually have Vehicle objects. The Vehicle class should probably be an abstract base class. Whether it is an abstract base class or a concrete class that is also a base class, the fact that it is a base class means that you should declare its destructor virtual since you may attempt to destroy a derived class object through a base class pointer.