Question

I’m having a hard time with templates and would like to ask some help.

First of all, I’m implementing a dynamic list, where the “data” of the node can be used to point whatever I need. It’s a generic list to all the application, and the way I found to make it was with templates.

Here is the .h where I implemented it:

#ifndef DYNAMICLIST_H_
#define DYNAMICLIST_H_

// **** Node ****
template <typename T>
class Node
{
public:
    Node(int _nodeID, T* _data)
    {
        nodeID = _nodeID;
        next = NULL;
        data = _data;
    }

    Node()
    {

    }

    ~Node()
    {
        if(data)
            delete data;
    }

    //sets e gets

    Node* GetNext() const
    {
        return next;
    }

    void SetNext(Node* _next)
    {
        next = _next;
    }

    int GetNodeID() const
    {
        return nodeID;
    }

    T* GetNodeData() const
    {
        return data;
    }

    void SetData(T* _data) //provavelmente não será usada
    {
        data = _data;
    }

private:

    int nodeID; //numero usado na busca
    Node* next; //ponteiro pro proximo node
    T* data;    //ponteiro pra uma imagem, uma mensagem, um som, o que quer que seja que precisar ser guardado
};





// **** DynamicList ****
class DynamicList
{
public:
    DynamicList(Node* _node)
    {
        this->SetHead(_node);
    }

    ~DynamicList()
    {
        this->DeleteList();
    }

    //sets e gets
    Node* GetHead() const
    {
        return head;
    }

    void SetHead(Node* _head)
    {
        head = _head;
    }

    Node* GetNode(int _nodeID) const
    {
        Node *Finder;
        if (!head)
            return false;
        Finder = head;
        for (; Finder; Finder = Finder->GetNext()) 
        {
            if (Finder->GetNodeID() == _nodeID) //se o nome for igual, retorna o ponteiro do node
                return Finder;
        }
        return false;
    }

    void NewNode (Node* _node) // Método para adicionar um elemento novo ao final da lista.
    {   
        if (!this->GetHead())
        {
            this->SetHead(_node);
        }
        else
        {
            Node *Finder = this->GetHead();
            while (Finder->GetNext())
                Finder = Finder->GetNext();
            Finder->SetNext(_node);
        }
    }

    //outras
    bool Delete(int _nodeID)
    {
        Node* deleter;
        Node* aux;

        if(!this->GetNode(_nodeID) ) //não há mensagem com esse Id na lista
            return false;

        if(head->GetNodeID() == _nodeID)
        {
            if (!head->GetNext()) //se não houver outro nó além da head, não deletar
            {
                delete head;
                head = NULL;
            }
            else
            {
                aux = head->GetNext(); //se head tiver a mensagem a ser deletada, head agora aponta para o nó seguinte
                delete head;
                head = aux;
                return true;
            }
        }
        else
        {
            deleter = head;

            while (deleter) //enquanto não chegar no fim
            {
                if (deleter->GetNext()) //se há um próximo node
                {
                    if (deleter->GetNext()->GetNodeID() == _nodeID) //verifica se o próximo tem a node mensagem procurada
                    {
                        aux = deleter->GetNext()->GetNext(); //caso tenha, perde o ponteiro do proximo node e pega o do seguinte
                        delete deleter->GetNext();
                        deleter->SetNext(aux);
                        return true;
                    }
                }
                deleter = deleter->GetNext(); //passa para o próximo
            }
            return false;
        }
    }

    void DeleteList()
    {
        Node* superDeleter;
        Node* aux;

        superDeleter = head;

        if(!superDeleter)
            return;
        else
        {
            while(superDeleter->GetNext()) //se há um próximo node
            {
                aux = superDeleter->GetNext(); //guarda o proximo
                delete superDeleter; //deleta o primeiro
                superDeleter = aux; //aponta para o proximo
            }
            delete superDeleter; //deleta o ultimo restante
        }
    }

private:

    Node* head;
};

#endif

My intention was to use template to make data a generic pointer to keep the class in the queue.
Check the methods in the class. Most of them use Node*, which I cursed by making it a template.
Now the Node* can’t be used without specifying the type in the declarations?
Is there a way to declare Node* so I can use it in this methods? My biggest problem is that inside the methods I can’t specify the node template, it should work with all types.

Thanks.

Answer 1

My biggest problem is that inside the methods I can’t specify the node template, it should work with all types

Yes, you can: just make DynamicList a template as well and then use Node<T>*. That way it will work with all types.