類對象不工作的Linkedlist模板

我已經創建了這個Dictionary類和一個以這個類為類型的Linkedlist模板。在main（）函數中，我試圖創建Dictionary類的對象，并將Dictionary作為Linkedlist模板的類型傳遞。稍后，當我將創建的Dictionary類對象傳遞給LinkedList的insertHead（）或initHead（）函數并嘗試通過訪問head的數據并調用Dictionary成員函數print（）來打印數據時，它不會打印數據（32，A）。insertHead（）打印“0-”，initHead（）給出分段錯誤。我有辦法解決這個問題嗎？

class Dictionary {
public:
    int index;
    string data;
public:
    Dictionary(int index = 0, string data = ""){
        this->index = index;
        this->data = data;
    }

    Dictionary(string data){
        this->data = data;
    }

    void setIndex(int index){
        this->index = index;
    }

    void setData(string data){
        this->data = data;
    }

    Dictionary operator=(Dictionary const & obj){
        Dictionary dict;
        dict.index = obj.index;
        dict.data = obj.data;
        return dict;
    }

    void print(){
        cout << index << "-" << data << endl;
    }

    friend bool operator== (const Dictionary &d1, const Dictionary &d2);
    friend bool operator!= (const Dictionary &d1, const Dictionary &d2);
};

bool operator== (const Dictionary &d1, const Dictionary &d2){
    return (d1.data == d2.data);
}

bool operator!= (const Dictionary &d1, const Dictionary &d2){
    return !(d1 == d2);
}


int main(){
    Dictionary d(32, "A");
    LinkedList<Dictionary> l;
    l.insertHead(d);
    l.head->data.print();
}

以下是LinkedList模板類的代碼：

#include <iostream>
using namespace std;

template <typename T>
class Node {
public:
    T data;
    Node *next;
    Node *prev;

    Node(){};
};

template <typename T>
class LinkedList {
public:
    Node<T> *head;
    Node<T> *tail;

public:
    LinkedList(){
        head = NULL;
        tail = NULL;
    }

    void initHead(T item){
        head->next = NULL;
        head->prev = NULL;
        head->data = item;
    }

    void insertHead(T item){
        Node<T> *tmp = new Node<T>();
        if (head == nullptr){
            head = tmp;
            head->prev = nullptr;
            head->data = item;
            head->next = nullptr;
            tail = tmp;
        } else {
            tmp->next = head;
            tmp->data = item;
            tmp->prev = nullptr;
            head->prev = tmp;
            head = tmp;
        }
    }

    void insertLast(T item){
        Node<T> *tmp = new Node<T>();
        tmp->data = item;
        if (head == nullptr){
            head = tmp;
            head->prev = nullptr;
            head->next = nullptr;
            tail = tmp;
        } else {
            tmp->prev = tail;
            tail->next = tmp;
            tmp->next = nullptr;
            tail = tmp;
        }
    }

    void insertNext(T item){
        Node<T> *tmp = new Node<T>();
        tmp->next = nullptr;
        tmp->data = item;
        tmp->prev = nullptr;

        Node<T> *iter = head;
        while (iter != nullptr){
            if (iter->next == nullptr){
                iter->next = tmp;
                tmp->prev = iter;
                return;
            }
            iter = iter->next;
        }
    }

    // Returns 0 if Not found. Always add a check
    // for 0 before accessing the tmp->data

    Node<T>* find(T item){
        Node<T> *tmp = head;
        while(tmp && tmp->data != item){
            tmp = tmp->next;
        }
        return tmp;
    }

    bool deleteNode(Node<T>* node){
        if (node == nullptr){
            return false;
        } else if (node == head){
            head = node->next;
            delete node;
            return true;
        } else {
            Node<T> *tmp = head;
            while (tmp){
                if (tmp->next == node){
                    tmp->next = node->next;
                    delete node;
                    return true;
                }
                tmp = tmp->next;
            }
        }
        return false;
    }

    void print(){
        Node<T> *tmp;
        tmp = head;
        while (tmp != nullptr){
            cout << tmp->data << "->";
            tmp = tmp->next;
        }
        cout << endl;
    }
};