Question

I have a base structure FooBase:

struct FooBase { };

Then I create a template structure Foo which is a child of FooBase:

template <typename typeName> struct Foo : public FooBase { typeName* foo };

In some class I create a vector of FooBase and add instances of Foo in it:

vector <FooBase> FooVector
...    
Foo <Bar> fooInstance;
fooInstance.foo = new Bar();
FooVector.push_back ( fooInstance );

Then I needed to access the stored data, but I’m getting predictable and obvious error about an absence of the member foo in FooBase

FooVector[0].foo

I can not write something like

Foo <Bar> fooInstance = FooVector[0]

since I don’t know the template parameter.

How do I store instances of Foo in the vector so I can access them later. Note, that I don’t know the template parameter at the last step – when reading data from the vector.

P.S. NO BOOST ALLOWED!

Answer 1

What happens here, is that in your

FooVector.push_back ( fooInstance );

line, C++ silently invokes the copy constructor of FooBase, because you can only keep objects of that type in your vector. Since Foo inherits publicly from FooBase the method FooBase::FooBase(FooBase const&) can be called with an object of type Foo.

So, you’re not really storing Foos, but in fact FooBases. To do what you want to do you need an std::vector<FooBase*> or std::vector<std::shared_ptr<FooBase> >.

However, the contents of your vector, will still lack a foo member, because the static type is still not Foo. To get around this, you have some options. You could dynamic_cast or static_cast your FooBase* into a Foo* and then access its foo member. But that could break, since the FooBase* pointers might actually hold another type than Foo.

Why don’t you just use an std::vector<Foo<Bar> > instead?