C++: Replacing Long Switch() Statement with Indexed Array?

Question

To create a game object dynamically, I take the ObjectTypeID, which is unsigned int, and let it compare within very long switch() statement. If the appropriate swith case is found, I create the object and store it. Because I already have 90 Game Objects, the Switch() is already very long and will be growing to about 300 objects.

To avoid the extra long switch() statement, and to improve speed, the perfect candidate would be taking advantage of indexed array to store all the object types (ObjectTypeID increases from 0 upward). Is there a way, how to store Object Type within an array?

I would like to use something like this:

• aObjectTypesArray[ObjectTypeID] *pNewDynamicObject = new aObjectTypesArray[ObjectTypeID];

Can you advise me, please, how to take advantage of dynamic array indexing in my case, and how to avoid extra long switch() statement? Your advice might differ from my idea, the key is to use array indexing and to remove long switch() statement.

Answer 1

In c++, classes are not first-class objects, so you cannot directly do what you want. But, if the game objects inherit from a common base class, you simply need to use a factory.

class GameObject {
};

class GameObjectFactory {
public:
  virtual GameObject * create() = 0;
};

class SomeGameObject : public GameObject {
};

class SomeGameObjectFactory : public GameObjectFactory {
  virtual GameObject * create() { return new SomeGameObject; }
};

Then store factory instances in your array.

Answer 2

An easier way to create factories is to use a template to create the factory method and then store it using a function pointer or perhaps boost::function or std::function if they're available.

For example, given the objects:

#include <iostream>

struct GameObject {
    virtual ~GameObject() {}
    virtual void foo() const = 0;
};

struct ExampleObject : GameObject {
    void foo() const { std::cout << "ExampleObject::foo\n"; }
};

We can use a template to define a generic object factory:

template <typename Object>
GameObject* object_factory() const
{
    return new Object();
};

Define a vector to store function pointers to factory methods:

#include <vector>

typedef GameObject*(*factory_ptr)();
std::vector<factory_ptr> factories;

Then add an object to the factories using something like:

int example_object_id = factories.size();
factories.push_back(&object_factory<ExampleObject>);

And then later create the object with:

GameObject* obj = factories[example_object_id]();

Here's a complete example:

#include <iostream>
#include <vector>

template <typename BaseObject>
class game_object_factory
{
    template <typename Object>
    static BaseObject* create_object()
    {
         return new Object();
    };

    typedef BaseObject*(*factory)();
    std::vector<factory> factories;

public:
    template <typename Object>
    int register_type()
    {
        int index = factories.size();
        factories.push_back(&create_object<Object>);
        return index;
    }

    BaseObject* create(int id) const {
        return factories[id]();
    }
};

struct GameObject {
    virtual ~GameObject() {}
    virtual void foo() const = 0;
};

struct Example1 : GameObject {
    void foo() const { std::cout << "Example1::foo\n"; }
};

struct Example2 : GameObject {
    void foo() const { std::cout << "Example2::foo\n"; }
};

int main() {
    game_object_factory<GameObject> factory;

    int obj1_id = factory.register_type<Example1>();
    int obj2_id = factory.register_type<Example2>();

    // Should use a smart pointer here to simplify memory management.
    GameObject* obj = factory.create(obj2_id);
    obj->foo();
    delete obj;
}

Answer 3

I think Erik has given an excellent answer, i.e. use the Factory design pattern and fill in your array with Factory instances.

My only note of caution would be that using IDs as array indices imposes a little maintenance overhead -- you need to make sure the IDs and the array contents match. Easy when you've got 10 IDs, not so straightforward when you have 300, definitely not so simple when the code has been maintained for a few months or years.

If you can stand the performance hit (and I appreciate that may be a dominant consideration) then it is better to use some sort of map (I leave implementation selection up to you!) where each entry of the array contains an ID and its corresponding factory instance. That way you can group objects logically rather than having to sort them numerically, and the object IDs do not need to be contiguous. But either way Factory is a good way to go.