c++ - 在模板中创建复制链表的函数时遇到问题

Question

作业是制作一个整数列表和做各种事情的函数。除了一个我都完成了。

在我想出如何制作一个函数来搜索特定值和节点的列表后，我必须制作一个复制所述列表的函数。但是，我在使用我现在拥有的 Material 执行此操作时遇到了严重的问题。

这是我正在使用的类(T 是模板)

    template <class T>
    class IntegerList{
    private:
    struct ListNode {
        T value;
        struct ListNode *next;
    };

    ListNode *head;
    public:
    //This is the constructor.
    IntegerList()
    {head = NULL;}

    //Destructor
    ~IntegerList();

    void appendNode(T);
    void insertNode(T);
    void deleteNode(T);
    void searchNode(T);
    void Duplicatenode(T);
    void displayList() const;
};

到目前为止的功能:

//==appendNode definition==
template<class T>
void IntegerList<T>::appendNode(T newValue) {
    ListNode *newNode;
    ListNode *nodePtr;

    newNode = new ListNode;
    newNode->value = newValue;
    newNode->next = NULL;

    if (!head) head = newNode;
    else {
        nodePtr = head;
        while (nodePtr->next)nodePtr = nodePtr->next;
        nodePtr->next = newNode;
    }

}

//==displayList Definition==
template<class T>
void IntegerList<T>::displayList() const {
    ListNode *nodePtr;
    nodePtr = head;

    while (nodePtr) {
        cout << nodePtr->value << "";
        nodePtr = nodePtr->next;
    }
    cout << endl;
}

//==insertNode Definiton==
template<class T>
void IntegerList<T>::insertNode(T newValue) {
    ListNode *newNode;
    ListNode *nodePtr;
    ListNode *previousNode = NULL;

    newNode = new ListNode;
    newNode->value = newValue;
    if (!head) {
        head = newNode;
        newNode->next = NULL;
    }
    else {
        nodePtr = head;
        previousNode = NULL;

        while (nodePtr != NULL && nodePtr->value < newValue) {
            previousNode = nodePtr;
            nodePtr = nodePtr->next;
        }
        if (previousNode == NULL) {
            head = newNode;
            newNode->next = nodePtr;
        }
        else {
            previousNode->next = newNode;
            newNode->next = nodePtr;
        }
    }
}

//==deleteNode Definition==
template<class T>
void IntegerList<T>::deleteNode(T searchValue) {
    ListNode *nodePtr;
    ListNode *previousNode = NULL;

    if (!head) return;
    if (head->value == searchValue) {
        nodePtr = head->next;
        delete head;
        head = nodePtr;
    }
    else {
        nodePtr = head;
    while (nodePtr != NULL && nodePtr->value != searchValue) {
        previousNode = nodePtr;
        nodePtr = nodePtr->next;
        }
        if (nodePtr) {
            previousNode->next = nodePtr->next;
            delete nodePtr;
        }
    }
}

//searchNode Definiton
template <class T>
void IntegerList<T>::searchNode(T searchValue)
{
    ListNode *nodePtr=0;
    nodePtr = head;
    int i = searchValue;
                //This variable is initiated to remember the number to search for. For use in if statement.
    int j = 0;          
                //This variable is dedicated to the position number, starting with 0. Increments by 1 when the while loop loops.
        while (nodePtr)
        {
            if (i == nodePtr->value) {
                //This if statemtent will return a success message with the position number if the number is found.
                cout << "\nThe value "<< nodePtr->value <<" was found in the list, in position " << j <<" of this list.\n";
                return;
            }
            else
            {
                nodePtr = nodePtr->next;
                j++;
            }
        }
        //This message only plays when it goes through the list without finding the value.
        cout << "\nThe value " << i << " was not found in this list.\n";
}

//==Duplicatenode Definition==
template<class T>
void IntegerList<T>::Duplicatenode(T)
{
    if (list == NULL) return NULL;

    ListNode* result = new ListNode;
    result->value = list->value;
    result->next = Clone(list->next);
    return result;
}



//==Destructor Definition==
template<class T>
IntegerList<T>::~IntegerList() {
    ListNode *nodePtr;
    ListNode *nextNode;
    nodePtr = head;
    while (nodePtr != NULL) {
        nextNode = nodePtr->next;
        delete nodePtr;
        nodePtr = nextNode;
    }
}

以及进行测试的主要功能。

int main() {
    IntegerList<int> list1;


    list1.appendNode(1);
    list1.appendNode(2);
    list1.appendNode(5);

    list1.displayList();
    list1.insertNode(4);

    list1.displayList();

    list1.deleteNode(2);
    list1.displayList();

    cout << "\nThis line breaks to denote searchNode function running.\n";

    list1.searchNode(5);
    list1.searchNode(3);

    cout << "\nLine break to denote copyNode function running.\n";

    IntegerList<int> list2(list1);
    list2.displayList();

    cin.ignore();
    cin.get();

    return 0;
}

四处搜索并没有给我有用或可用的答案。有没有一种方法可以在保持模板不变的情况下这样做？

Answer 1

查看提供的源代码时，复制list1的方法作为 list2尚未完成。

分析 - 使用现有的 class IntegerList , 使用IntegerList<int> list2(list1);复制将仅在数据级别执行。该类只包含一个指针数据ListNode *head;并且默认的复制构造函数将复制 list1->head进入list2->head .结果是:

1. 使用appendNode()或 insertNode()与 list1会将相同的节点添加到 list2 中,
2. 使用deleteNode()与 list1将删除相同的节点到 list2 ,
3. 使用displayList()与 list2将与 list1 相同.

解决方案 - 执行 list1 的复制进入list2并允许独立管理两个列表，有必要添加您自己的复制构造函数。

In the class IntegerList declaration, append the copy-constructor. The source list is passed-by reference.

IntegerList(IntegerList& src);

然后添加复制构造函数实现。

1. 目的地 ListNode *head;初始化为 NULL在开始复制之前，
2. 源列表是从 src.head 中探索的直到 NULL如 displayList()功能，
3. 使用appendNode()将每个源节点添加到目标列表中,

建议的复制构造函数:

template<class T>
IntegerList<T>::IntegerList(IntegerList& src) : head(NULL) {
    ListNode *nodePtr;
    nodePtr = src.head;

    while (nodePtr) {
        appendNode(nodePtr->value);
        nodePtr = nodePtr->next;
    }
}

No change needed in the main() function. The use of IntegerList<int> list2(list1); will automatically call the specific copy-constructor instead of the default one.