[C++] Creating a class for any type of variable?

[DrEvil]

So I created a linked list class for 'Enemy' class, and while this works, I would like to expand the 'LinkedList' class to be able to work for any type of variable:

class EnemyList{
    private:
        class Node{
            public:
                Node* _next;
                Enemy _enemy; //<--- Change Enemy to whatever type
                //int id;
        };
 
    public:
        Node* _head;
 
        EnemyList(){_head=NULL;};
 
        void addEnemy(Enemy enemy); //<--- Change Enemy to whatever type
        void deleteEnemy(Enemy enemy); //<--- Change Enemy to whatever type
 
};

EnemyList<int> ?

Like I have seen this before on thing such as vector<int>; vector<Enemy>.
How do I create something like this, which doesn't have a set type.

Like I know I'd have to rethink the delete<type> method but I'l take it one step at a time...
(Also any ideas on how the deleteElement function could work would also be appreciated, as the current method is comparing an index: enemy.index==(tempNode).index, then removing)

 

[UnknowVector]

> How do I create something like this, which doesn't have a set type.

http://www.cplusplus.com/doc/tutorial/templates/

That or void pointers.

XD.

Seriously though, templates.

> void deleteEnemy(Enemy enemy);

Exactly how do you expect this to work? It looks to me like you are passing the enemy-to-delete in by value (i.e. you are copying it), and then comparing the copy to the enemies stored in the list based on their indexes. So any "two" enemies with the same index should be treated as the same object.

(Also, I can't be sure, but I think "id" might be a better name here. Unless index really is the index of the enemy in the list. If you can insert and remove from the list without updating your enemies "indexes" then they are really ids.)

If you want your list to work on as many classes as possible, you should rely on the equality operator. Any class can define an equality operator, even if it just compares the memory addresses of it's right hand and left hand side arguments; once it does that it will work in your delete function. This even lets you store all the primitive types for free, since they obviously have their own equality operator. This re-raises something I hinted at earlier: you need to know what it means for one enemy to compare equal to another. If you pass an enemy by value, making a local copy, are they still the same enemy?

Otoh, if every class of objects you store in the list will have an index/id, you could rely on that if you wanted. fooitem.value == baritem.value.

If you try to declare a list of something that doesn't have the proper members (needs equality operator, lacks it; needs index member, lacks it; etc.) you'll get a compile time error.

 

[GFreak45]

a template is used as a way to use a "generic type" as a type saved in a class or as a function

it looks like this:

template<class TYPE> class a
{
public:
    TYPE member;
};

or

template<class TYPE> TYPE add (TYPE a, TYPE b)
{
    return a + b
}

then you can use each of these like so:

int x = 0
a<int> aexample;
aexample.member = x;
x = add(x, x);

notice the class variable declaration has the <int> on it, whereas the function call does not, if you are calling a simple function, it will choose the best option, this wont work for functions that only use the class template for a return.

Also, there are optional class parameters, for example:

template<class TYPE, class RETURN = TYPE, class TYPE_TWO = TYPE>
RETURN add (TYPE a, TYPE_TWO b)
{
    return (RETURN)(a + (TYPE)b)
}

so you can call it one of the 3 ways:

int x = add<int>(1, 2)
double y = add<int, double>(1, 3)
float z = add<int, float, double>(2, 3.5)

so the type of the return and second argument default to the type of the first template parameter