managing objects derived from the same base class using a container

[Calin Negru]

I can`t think of a way to store in an array objects of different type but with same base class so I`m going to use a STL container instead:

class somebaseclass
{

}
class derivedclass: private somebaseclass
{

}
class anotherderivedclass: private somebaseclass
{

}

vector * AllObjects;
derivedclass * Derived1 = new derivedclass[1];
anotherderivedclass * Derived2 = new anotherderivedclass[1];

AllObjects->push_back((somebaseclass)Derived1);
AllObjects->push_back((somebaseclass)Derived2);

Is this how it should be done?

[Mircea Neacsu]

That works but the more modern (and safe) way to do it is to use unique_ptr instead of raw pointers. Something like this:

std::unique_ptr p1 = make_unique(args1);
std::unique_ptr p2 = make_unique(args2);

std::vector> container;
container.push_back (p1);
container.push_back (p2);

Mircea

[Greg Utas]

Yes. If objects belong to different classes, the only way to store them in a container is to use pointers, because the container allocates the same amount of memory for each entry. If you also want the container to delete an entry when you erase it, declare it as, for example, vector>.

Robust Services Core | Software Techniques for Lemmings | Articles
The fox knows many things, but the hedgehog knows one big thing.

[Lost User]

Yes, except for: 1. Why are you using an array size reference in your instantiations? All you should need is:

derivedclass * Derived1 = new derivedclass();

2. Your container is defined to use somebaseclass * types, so your calls to push_back should be:

AllObject->push_back((somebaseclass*)Derived1);

or better still, using proper C++ casts:

AllObject->push_back(reinterpret_cast(Derived1));

[Calin Negru]

thanks, that helps.

[Calin Negru]

Quote:

because the container allocates the same amount of memory for each entry

that is an interesting fact

[Lost User]

You are welcome. I also think @Mircea-Neacsu's advice about unique_ptr is well worth taking.

[Calin Negru]

pointers from a library, that`s a topic that`s a bit too advanced or complicated for my present day understanding.

[k5054]

If you can handle raw pointers, then C++ smart pointers should be easy to understand. Google for C++ unique_pointer tutorial and read through a few of the returned hits. It's fairly straight forward, and in general new C++ development should use the smart pointers instead of using raw (e.g. new/delete).

Keep Calm and Carry On

[Lost User]

It's a lot simpler than classes and inheritance. :laugh:

[Calin Negru]

The problem is I hate complicated syntax. Containers are already complicated syntax for me, combine that with another object (pointer) from a library and it becomes unintelligible mess. I will use a complicated feature when I really need to use it and there is no other way around it. Usually I need to use a feature a couple months before I can move on to something more complicated.

[Calin Negru]

Richard you really think so?

[Lost User]

Did you notice the :laugh: icon?

[Calin Negru]

ok, it was a joke

[Calin Negru]

I guess converting the object(pointer) back to it`s original form when time comes to use it somewhere works the same

derivedclass * DerClpointer1 = (derivedclass *)AllObjects->at(0);

Is there a way to check is the conversion is valid? like if an object is of a certain type. For instance how do I convert all objects to their derived state type in a for loop?

for(int i =0; i< AllObjects->size();i++ )
{
// if AllObjects->at(i) is of type derivedclass covert to derivedclass
}

[Lost User]

Calin Cali wrote:

guess converting the object(pointer) back to it`s original form when time comes to use it somewhere works the same

Yes it should do, but you need to run some tests to make sure.