Using a(n empty) base class to enable storing different objects in the same container

问题

Say I have two different objects that are completely different, Sprite and PhysicsData.

I write an empty base class and a container class that can push and remove objects to/from a container.

I create two of these containers to store the two different objects - Sprite and PhysicsData. (Different objects aren't together in the same class)

class base
{
};

class ContainerManager
{
public:
    std::vector<base*> list;
    void Push(base *object);
    void Remove(base *object);
};

class PhysicsData : public base
{
    void applyGravity();
};

class Sprite : public base
{
    void Draw();
};

ContainerManager SpriteContainer;
ContainerManager PhysicsDataContainer;

Sprite aSprite;
SpriteContainer.Push(&aSprite);

PhysicsData SomeData;
PhysicsDataContainer.Push(&SomeData);

Is this the way that this should bet done?

回答1:

This is not a C++ way. You should use templates.

For you to know, STL (which you are calling to when using std:: namespace prefix) is, actually, Standard Template Library :). A lot of template classes are already there, e.g. for the push / remove operations see std::list<T>

You use it like this:

std::list<Sprite> SpriteContainer;
std::list<PhysicsData> PhysicsDataContainer;

and so on.

There is a cool guide about C++ templates, if you still want to do your own class for some more functionality.
And there is a reference to std::list, (i don't think i need to explain the usage of std::vector for you) if the question was the actual thing you've wanted to do.

回答2:

You're having Templates in C++ and still worrying about having a common base class for a trivial container??

template <class T>
class Container{
  private:
    vector<T> list;
  public:
    void Push(T data);
    T Pop();
};

回答3:

If you put a single virtual function into the base class, you'll be able to use dynamic_cast to get back the proper pointer if you mix different types in the same container. A virtual destructor would be a good idea because then you could delete the object if it were dynamically allocated, without having to cast it back to the original pointer.

If you're not going to mix types within a single container, I agree with dreamzor that a template class would be better. That's the way all the standard containers are implemented.

回答4:

That looks like technically correct code but you are not doing any type checking. So as you can see PhysicsData is showing up in your SpriteContainer. You probably do not want this.

There is more than one way to keep PhysicsData out of your SpriteContainer. One way is to use templates. With templates you would state what type of base objects the container should work with at compile time.

Another method is to inherit from your ContainerManager two types of ContainerManagers, one called PhysicsContainerManager and one called SpriteContainerManager. These two child classes can do type check to verify that the objects being passed are in fact either a SpriteContainer or a PhisicsData. This link shows how to do type check in c++ C++ equivalent of instanceof

thanks jose

来源：https://stackoverflow.com/questions/12923294/using-an-empty-base-class-to-enable-storing-different-objects-in-the-same-cont

标签

c++

containers