Question

赋值是创建执行各种操作的整数和函数列表。我只完成了一次。

在我弄清楚如何创建一个在列表中搜索特定值和节点的函数之后，我必须创建一个复制所述列表的函数。但是，我现在用我现有的材料做这件事很麻烦。

这是我正在使用的课程（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。结果是：

将appendNode()或insertNode()与list1一起使用会将同一节点添加到list2，
将deleteNode()与list1一起使用，会将同一节点移至list2，
将displayList()与list2一起使用将与list1相同。

解决方案 - 要将list1的副本执行到list2并允许独立管理这两个列表，必须添加自己的copy-Constructor。< / p>

在class IntegerList声明中，附加复制构造函数。源列表通过引用传递。

IntegerList(IntegerList& src);

然后添加copy-constructor实现。

在开始复制之前，目标ListNode *head;初始化为NULL
源代码列表从src.head到NULL进行探讨，与displayList()函数一样，
使用appendNode()，

建议的复制构造函数：

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

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

main()功能无需更改。指某东西的用途 IntegerList<int> list2(list1);会自动调用特定的复制构造函数而不是默认构造函数。

在模板中创建复制链表的功能时遇到问题

1 个答案: