Thread: Dynamic Lists? Is it possible? Is it a logical solution?

To start, I will present my problem, and then explain the possible solutions I can't seem to implement properly.

Problem: I have a basic struct (shown below), that all objects inherit from. I also have a simple derived class that I want to add to a static list on creation.

However, I would like for there to be separate lists created for each object type.

So, I would like a list to be created for every type of object...even new ones that someone creates, which eliminates the possibility of creating a static list of objects to add to for every object type.

Code:

struct Base
{
protected:
    int ID;
}

Code:

class Derived1
{
public:
    Derived(int x):ID(x) {}
};

Code:

class Derived1
{
public:
    Derived(int x):ID(x) {}
};

Using this structure, how could I dynamically create lists for the derived1 and derived2 classes?

I thought that I could create a list of lists of type T, like so:

Code:

template<class T> static List<List<T>> Lists

then populate it like this:

Code:

if(Lists.Contains(List<Derived1>)
{
    Lists.Get(List<Derived>).Add(derived1);
}
else
{
    Lists.Add(List<Derived>());
    Lists.Get(List<Derived>).Add(derived1);
}

however...this is pure psuedocode, and apparently you can't create an list of lists of type T....
...does anyone know a standard or intelligent solution to this? Creating dynamic lists, for every type created, to store and track every custom object in your program...


Seems like something that would be incredibly useful. Let me know if you guys find anything!

Alright...well I have to cut certain things out. But here is what I'm working with:


Base Object:

Code:

#ifndef _OBJ_H_
#define _OBJ_H_
#include <new>
#include "linkedlist.h"
#include "activeobjects.h"
class Object
{
public:
	~Object(void) {/*ActiveObjects::List.Add(LinkedList<this>().Add(this));*/}
protected:
	Object(void) {}
	int _ID;
};
#endif

Static List

Code:

#ifndef _ACTIVEOBJECTS_H_
#define _ACTIVEOBJECTS_H_
#include "linkedlist.h"
class ActiveObjects
{
public:
	static LinkedList<LinkedList<void**>*> List;
private:
	ActiveObjects(void);
};
//template<typename type> LinkedList<LinkedList<type*>*> ActiveObjects::List = LinkedList<LinkedList<type*>*>();
#endif

What I'm attempting to do, is simply make it so that whenever you initialize an object that inherits from "Object", it will immediately be stored in a list of pointers so I can keep track of their ID and the actual object to see if it is being deleted properly...
I just thought it would be a nice way to make debugging much easier.

So...I could do a list like this: List<Object> objects;
But that wouldn't organize them well, and anyone who uses this code, would have to create a new list in the source whenever they create a new object (if I choose to use different lists for each object type).

I thought that doing a list of lists of type T would work just fine. But you can't throw a generic type into a generic class that requires a type.

For example:

Code:

template <class T> List<T> objects;

won't compile.

Code:

List<Object> objects

will compile.

Code:

List<void*> objects

<-- this is more along the lines of what I'm trying to do. But I would really like to hear everyone elses opinion on this.

I think this comes down to what you think you mean when you say "see if it is being deleted properly". If the objects are just being created, then they will be destroyed when they go out of scope with or without you doing anything about it. If you're doing a lot of new'ing and worried about forgetting to delete, then that's a concern, but that has nothing to do with the class and everything to do with being less forgetful. (And in that case, then I would think a plain list or set of Object* would suffice -- it doesn't seem like you would need to sort that by type.) If there's lots of memory management going on inside the object, then that would probably have to be done by the object, not by the class.

Very true, tabstop.

However, I was forced to overload the new and delete keywords, and do a few other things that make me need to check the memory.

As far as the lists go, a better example is this....

I have a bullet list, and a player list...
the bullets inherit from object, and so does player.
When bullet is initialized, it goes into a list for bullets.
When player is initialized, it goes into a list for players.
The lists then number their IDs respective to their position in the list.
This way, Player #1 would have an ID of 1, and bullet #1 would have an ID of one as well.

This allows me to select the appropriate list and iterate through the collection that I need, rather than iterating through 50,000 objects to get to my players.

This is the main reason I have wanted to create this list of lists.

Okay...I have to admit...that is a pretty piece of code :P

That is very very similar to what I'm doing...or at least trying to do haha.
The only issue is that it appears that if I have 10000 bullets on the screen, and a new player emerges, it will have to iterate through all those bullets to find him...


I REALLY thank you for that nice chunk of code though! Any ideas on how to make it more dynamic for my purposes?