Linked List of linked lists trouble

Question

I am having trouble implementing this with the class I have. So far as a linkedlist of type int or string it works great, but I am not sure how to navigate the list if I initialize it like

linkedlist<linkedlist<int>> nums;

From my program it seems that the head of each secondary list would be an entry in the primary, but my question is how would I navigate it?. For example how would I print all the values of each linkedlist, I am sure I am making this more difficult than it it, but any help would be appreciated.

/* Node Class */
template <typename T>
class Node {
    public:
        T data;
        Node* next;
        Node* previous;
        Node(T data);
        Node();
        T getData();
};

template <typename T>
Node<T>::Node() {
    this->next = NULL;
    this->previous = NULL;
}

template <typename T>
Node<T>::Node(T data) {
    this->data = data;
}

template <typename T>
T Node<T>::getData() {
    return this->data;
}

/* Linked List: */
template <typename T>
class linkedlist {
    private:
        Node<T>* head;
        Node<T>* tail;
        int list_size;
    public:
        linkedlist();
        T getHead();
        T getTail();
        int size();
        void addnodetail(T);
        void addnodehead(T);
        void push(T);
        T pop();
        //T* peek();
        bool isEmpty() const {
                return head == NULL;
            }
        //T* get(int index);
        void printlist();
        void printListBackwards();
        ~linkedlist();
};

template <typename T>
linkedlist<T>::linkedlist() {
    this->head = NULL;
    this->tail = NULL;
    this->list_size = 0;
}

template <typename T>
T linkedlist<T>::getHead() {
    return this->head->data;
}

template <typename T>
T linkedlist<T>::getTail() {
    return this->tail->data;
}

template <class T>
int linkedlist<T>::size() {
    return this->list_size;
}

template <typename T>
void linkedlist<T>::addnodetail(T input) {
    Node<T>* newnode = new Node<T>(input);
    newnode->next = NULL;
    newnode->previous = NULL;

    if (this->head == NULL) {
        this->head = newnode;
        this->tail = this->head;
        this->list_size = this->list_size + 1;
    } else {
        this->tail->next = newnode;
        newnode->previous = this->tail;
        this->tail = newnode;
        this->list_size = this->list_size + 1;
    }
}

template <typename T>
void linkedlist<T>::addnodehead(T input) {
    Node<T>* newnode = new Node<T>(input);
    newnode->next = NULL;
    newnode->previous = NULL;

    if (this->head == NULL) {
        this->head = newnode;
        this->tail = this->head;
        this->list_size = this->list_size + 1;
    } else {
        this->head->previous = newnode;
        newnode->next = this->head;
        this->head = newnode;
        this->list_size = this->list_size + 1;
    }
}

template <typename T>
void linkedlist<T>::push(T input) {
    this->addnodehead(input);
}

template <typename T>
T linkedlist<T>::pop() {
    Node<T>* temp = this->head;
   // T* temp = this->head;
    this->head = this->head->next;
    this->head->previous = NULL;
    this->list_size = this->list_size - 1;
    return temp->data;
}
/*
template <class T>
T* MyList<T>::peek() {
    return this->head;
}


template <class T>
T* MyList<T>::get(int index) {
    if (index == 0) {
        return this->head;
    } else if (index == this->list_size - 1) {
        return this->tail;
    } else if (index < 0 || index >= this->list_size) {
        return NULL;
    }
    if (index < this->list_size / 2) {
        T* temp = this->head;
        int i = 0;
        while (temp) {
            if (i == index) { return temp; }
            i++;
            temp = temp->next;
        }
    } else {
        T* temp = this->tail;
        int i = this->list_size - 1;
        while (temp) {
            if (i == index) { return temp; }
            i--;
            temp = temp->previous;
        }
    }
    return NULL;
}*/

template <typename T>
void linkedlist<T>::printlist() {
    cout << "HEAD:  ";
    Node<T>* temp = this->head;
    while(temp) {
        cout << temp->data << " -> ";
        temp = temp->next;
    }
    cout << "\b\b\b\b  :TAIL" << endl;
}

template <class T>
void linkedlist<T>::printListBackwards() {
    cout << "TAIL:  ";
    Node<T>* temp = this->tail;
    while(temp) {
        cout << temp->data << " -> ";
        temp = temp->previous;
    }
    cout << "\b\b\b\b  :HEAD" << endl;
}

template <typename T>
linkedlist<T>::~linkedlist() {
    for(Node<T>* p;!isEmpty();){
        p = head->next;
        delete head;
        head = p;
    }
}

EDIT with copy constructor

---

#ifndef LINKEDLIST_H
#define LINKEDLIST_H
#include <iostream>
#include <ctype.h>
using namespace std;

using namespace std;



/*struct AdjListNode
{
    int dest;
    struct AdjListNode* next;
};

// A structure to represent an adjacency list
struct AdjList
{
    struct AdjListNode *head;  // pointer to head node of list
};

// A structure to represent a graph. A graph is an array of adjacency lists.
// Size of array will be V (number of vertices in graph)
struct Graph
{
    int V;
    struct AdjList* array;
};

// A utility function to create a new adjacency list node
struct AdjListNode* newAdjListNode(int dest)
{
    struct AdjListNode* newNode =
            (struct AdjListNode*) malloc(sizeof(struct AdjListNode));
    newNode->dest = dest;
    newNode->next = NULL;
    return newNode;
}

// A utility function that creates a graph of V vertices
struct Graph* createGraph(int V)
{
    struct Graph* graph = (struct Graph*) malloc(sizeof(struct Graph));
    graph->V = V;

    // Create an array of adjacency lists.  Size of array will be V
    graph->array = (struct AdjList*) malloc(V * sizeof(struct AdjList));

     // Initialize each adjacency list as empty by making head as NULL
    int i;
    for (i = 0; i < V; ++i)
        graph->array[i].head = NULL;

    return graph;
}

// Adds an edge to an undirected graph
void addEdge(struct Graph* graph, int src, int dest)
{
    // Add an edge from src to dest.  A new node is added to the adjacency
    // list of src.  The node is added at the begining
    struct AdjListNode* newNode = newAdjListNode(dest);
    newNode->next = graph->array[src].head;
    graph->array[src].head = newNode;

    // Since graph is undirected, add an edge from dest to src also
    newNode = newAdjListNode(src);
    newNode->next = graph->array[dest].head;
    graph->array[dest].head = newNode;
}

// A utility function to print the adjacenncy list representation of graph
void printGraph(struct Graph* graph)
{
    int v;
    for (v = 0; v < graph->V; ++v)
    {
        struct AdjListNode* pCrawl = graph->array[v].head;
        printf("\n Adjacency list of vertex %d\n head ", v);
        while (pCrawl)
        {
            printf("-> %d", pCrawl->dest);
            pCrawl = pCrawl->next;
        }
        printf("\n");
    }
}
*/

/* Node Class */
template <typename T>
class Node {
    public:
        T data;
        Node* next;
        Node* previous;
        Node(T data);
        Node();
        T getData();
};

template <typename T>
Node<T>::Node() {
    this->next = NULL;
    this->previous = NULL;
}

template <typename T>
Node<T>::Node(T data) {
    this->data = data;
    this->next = NULL;
}

template <typename T>
T Node<T>::getData() {
    return this->data;
}

/* Linked List: */
template <typename T>
class linkedlist {
    private:
        Node<T>* head;
        Node<T>* tail;
        int list_size;
    public:
        linkedlist();
        linkedlist(linkedlist& object);
        T getHead();
        T getTail();
        int size();
        void addtail(const T& input);
        void addhead(const T& input);
        void push(T);
        T pop();
        //T* peek();
        bool isEmpty() const {
                return head == NULL;
            }
        //T* get(int index);
        void printlist();
        void printListBackwards();
        ~linkedlist();
};

template <typename T>
linkedlist<T>::linkedlist() {
    this->head = NULL;
    this->tail = NULL;
    this->list_size = 0;
}

template <typename T>
linkedlist<T>::linkedlist(linkedlist &object){
    if(object.head == NULL){
        head == NULL;
    }
    else {
        head = new Node<T>(object.head->data);
        Node<T>* temp = head;
        Node<T>* objecthead = object.head;
        Node<T>* current = objecthead;
        while(current->next != NULL){
            temp->next = new Node<T>(current->next->data);
            current = current->next;
            temp = temp->next;
        }
    }
}

template <typename T>
T linkedlist<T>::getHead() {
    return this->head->data;
}

template <typename T>
T linkedlist<T>::getTail() {
    return this->tail->data;
}

template <class T>
int linkedlist<T>::size() {
    return this->list_size;
}

template <typename T>
void linkedlist<T>::addtail(const T& input) {
    Node<T>* newnode = new Node<T>(input);
    newnode->next = NULL;
    newnode->previous = NULL;

    if (this->head == NULL) {
        this->head = newnode;
        this->tail = this->head;
        this->list_size = this->list_size + 1;
    } else {
        this->tail->next = newnode;
        newnode->previous = this->tail;
        this->tail = newnode;
        this->list_size = this->list_size + 1;
    }
}

template <typename T>
void linkedlist<T>::addhead(const T& input) {
    Node<T>* newnode = new Node<T>(input);
    newnode->next = NULL;
    newnode->previous = NULL;

    if (this->head == NULL) {
        this->head = newnode;
        this->tail = this->head;
        this->list_size = this->list_size + 1;
    } else {
        this->head->previous = newnode;
        newnode->next = this->head;
        this->head = newnode;
        this->list_size = this->list_size + 1;
    }
}

template <typename T>
void linkedlist<T>::push(T input) {
    this->addhead(input);
}

template <typename T>
T linkedlist<T>::pop() {
    Node<T>* temp = this->head;
    if(temp != NULL){
    this->head = this->head->next;
    this->head->previous = NULL;
    this->list_size = this->list_size - 1;
    return temp->data;
    }
    else{
        cout << "Error:Empty List!";
            exit (EXIT_FAILURE);
    }
}
/*
template <class T>
T* MyList<T>::peek() {
    return this->head;
}


template <class T>
T* MyList<T>::get(int index) {
    if (index == 0) {
        return this->head;
    } else if (index == this->list_size - 1) {
        return this->tail;
    } else if (index < 0 || index >= this->list_size) {
        return NULL;
    }
    if (index < this->list_size / 2) {
        T* temp = this->head;
        int i = 0;
        while (temp) {
            if (i == index) { return temp; }
            i++;
            temp = temp->next;
        }
    } else {
        T* temp = this->tail;
        int i = this->list_size - 1;
        while (temp) {
            if (i == index) { return temp; }
            i--;
            temp = temp->previous;
        }
    }
    return NULL;
}*/

template <typename T>
void linkedlist<T>::printlist() {
    cout << "STACK" << endl;
    cout << "-------------------" << endl;
    Node<T>* temp = this->head;
    while(temp) {
        cout << "\t" << temp->data << endl;
        temp = temp->next;
    }
    //cout << "\b\b\b\b  :TAIL" << endl;
}

template <class T>
void linkedlist<T>::printListBackwards() {
    cout << "TAIL:  ";
    Node<T>* temp = this->tail;
    while(temp) {
        cout << temp->data << " -> ";
        temp = temp->previous;
    }
    cout << "\b\b\b\b  :HEAD" << endl;
}

template <typename T>
linkedlist<T>::~linkedlist() {
    for(Node<T>* p;!isEmpty();){
        p = head->next;
        delete head;
        head = p;
    }
}


#endif // LINKEDLIST_H