Data structure that can hold multiple types of data

Question

Like the title says, I'm looking for some kind of data structure which will allow me to store any type of class into it that I need at the time. For example:

Foo *foo = new Foo();
Bar *bar = new Bar();
someContainer.push_back( foo );
someContainer.push_back( bar );
someContainer.access( 0 )->doFooStuff();
someContainer.access( 1 )->doBarStuff();

Ideally, as I showed there, it would also allow me to access the contents and use their functions/etc.
I want one of these as I am attempting to create an "invisible" memory management system that just requires a class to inherit my memory manager class, and everything will work automagically.
Here is an example of what I want the code to look like:

template< class T >
class MemoryManaged
{
   MemoryManaged()
   {
      container.push_back( this );
   }
   void *operator new()
   {
       // new would probably be overloaded for reference counting etc.
   }
   void operator delete( void *object )
   {
       // delete would most definitely overloaded
   }
   T &operator=( T &other )
   {
      // = overloaded for reference counting and pointer management
   }

   static SomeContainer container;
}

class SomeClass : public MemoryManaged< SomeClass >
{
   // some kind of stuff for the class to work
};
class AnotherClass : public MemoryManaged< AnotherClass >
{
   // more stuff!
};

I hope that my code helps make clear what exactly it is I want to do. If someone knows some kind of already-built data structure that would allow me to do this, that would be awesome. Otherwise, I am currently working on building some kind of shambling zombie of a linked list class that uses templated nodes in order to link any type of class to any other type of class. I still have no idea how I'd get it to work yet, and I would love to be spared the blood, sweat, and tears (and hair) it would take to figure out how to make it work.

Answer 1

Have a common base class for all of your multiple types. Have the data structure hold onto pointers of your base class's type.

Answer 2

Take a look at boost::any and boost::variant.

Answer 3

Would some hybrid of template specialization and double-dispatch help? Something like this:

class IContainable;
class Operation
{
public:
   template<class ElementType> void Process(ElementType* pEl) {
      // default is an unrecognized type, so do nothing
   }
};

class IContainable
{
public:
    virtual void OperateOn(Operation* pOperation) = 0;
};


class Foo : public IContainable
{
public:
    int GetFooCount() { return 1; }
    virtual void OperateOn(Operation* pOperation);
};

// specialization of the operation for Foo's
template <> void Operation::Process<Foo>(Foo* pFoo)
{
     std::cout << pFoo->GetFooCount() << std::endl; 
}

void Foo::OperateOn(Operation* pOperation)
{
   pOperation->Process(this);
}

int main()
{
    typedef std::vector<IContainable*> ElementVector; 
    ElementVector elements;
    // configure elements;
    Operation oper;
    for(ElementVector::iterator it = elements.begin(); 
         it != elements.end(); it++)
    {
        (*it)->OperateOn(&oper);
    }
}

If the list of types in the container isn't known at compile time of the operations of the elements on the container, or they are distributed across modules that are not compiled together, then you could instead use dynamic_cast. You'd define a "IFooHandler" class witha pure virtual method called "HandleFoo" that takes a foo pointer. You'd make Operation::Process virtual and have your operation class derive from both Operation and IFooHandler and implement the operation in HandleFoo(). Your Foo::OperateOn method would dynamic_cast(pOperation) and if the result was non-null, it would call HandleFoo() on the IFooHandler pointer you get from the dynamic cast. Otherwise you'd call the generic Operation::Process and it would have some non-type-specific behavior.

Answer 4

Using a std::vector<T*> should work. Indeed, a new class will be created for each instantiation of MemoryManaged. This means that MemoryManaged<Foo> and MemoryManaged<Bar> will be totally different types. Consequently, the static member container will not be common to these two classes. It will be as if you had the two following classes:

class MemoryManagedFoo
{
    MemoryManagedFoo()
    {
        //Here, you know that 'this' is a Foo*
        container.push_back(this); //ok, we add 'this' to a container of Foo*
    }

    static std::vector<Foo*> container;
};

class MemoryManagedBar
{
    MemoryManagedBar()
    {
        //Here, you know that 'this' is a Bar*
        container.push_back(this); //ok, we add 'this' to a container of Bar*
    }

    static std::vector<Bar*> container;
};

As you can see, the static member is not shared by the two instantiations.

Of course, this solution assumes that MemoryManaged will always be used using CRTP, as you described in your question. In other word, this code will work:

class Foo : public MemoryManaged<Foo> { };

but not this one:

class Foo : public MemoryManaged<Bar> 
{
    // Here, 'container' is a 'vector<Bar*>' and 'this' is a Foo * --> problem
};