C++基础模板类使用

Question

//LinkedListNode.h
#pragma once
template <typename T>
class LinkedListNode
{
public:
    T data; // 节点存储的数据
    LinkedListNode* next; // 指向下一个节点的指针

    // 构造函数， 初始化数据和下一个节点的指针
    LinkedListNode(T data, LinkedListNode* next = nullptr) : data(data), next(next) {}
    ~LinkedListNode() {
        delete next;
    }
};

//LinkedListNode.h
#pragma once
#include "LinkedListNode.h"
template <class T>
class OnewayLinkedList
{
private:
    LinkedListNode<T>* head; //指向链表头部指针
    LinkedListNode<T>* tail; //指向链表尾部指针

public:
    OnewayLinkedList() :head(nullptr), tail(nullptr) {}
    ~OnewayLinkedList() {
        delete head;
        delete tail;
    }
    void add(T data);
    void remove(T data);
    void print() const;
};

//OnewayLinkedList.cpp
#include <iostream>
#include "OnewayLinkedList.h"

template <class T>
void OnewayLinkedList<T>::add(T data) {
    auto* newNode = new LinkedListNode<T>(data);
    if (head == nullptr) {
        head = tail = newNode;
    }
    else {
        tail->next = newNode;
        tail = newNode;
    }
}

template <class T>
void OnewayLinkedList<T>::remove(T data) {
    if (head == nullptr) {
        std::cout << "链表中没有元素了" << std::endl;
        return;
    }
    if (head->data == data) { // 如果头节点就是要删除的节点
        LinkedListNode<T>* temp = head;//保存头节点指针
        head = head->next;//头指针指向下一个节点
        temp->next = nullptr;//将原头节点的next设置为nullptr，防止删除整个链表
        delete temp;
        return;
    }
    // 如果头节点不是要删除的节点，那么遍历链表，找到要删除的节点
    LinkedListNode<T>* current = head;//保存头节点指针
    while (current->next != nullptr && current->next->data != data)
    {
        // 继续往下找
        current = current->next;
    }

    //找到要删除的节点
    if (current->next != nullptr) {
        //首先保存要删除的节点指针
        LinkedListNode<T>* temp = current->next;
        //将当前节点的next指向要删除节点的下一个节点
        current->next = current->next->next;
        //将要删除的节点的next设置为nullptr
        temp->next = nullptr;
        delete temp;
    }
}

template <class T>
void OnewayLinkedList<T>::print() const {
    LinkedListNode<T>* current = head;
    while (current != nullptr) {
        std::cout << current->data << " ";
        current = current->next;
    }
    std::cout << std::endl;
}

//main.cpp
#include <iostream>
#include "OnewayLinkedList.h"

using namespace std;
int main() {
    std::cout << "Hello, World!" << std::endl;

    OnewayLinkedList<int> intList;
    intList.add(1);
    intList.add(2);
    intList.add(3);
    intList.add(4);
    intList.remove(1);
    intList.print();
    return 0;
}

为什么什么编译不通过呢？我应该如何写呢？

Answer 1

基于Monster 组和GPT的调写：

• 在C++中，模板类和函数的定义通常都要在头文件中进行，而不是在源文件（如.cpp文件）中。

• 你的 OnewayLinkedList 类是一个模板类，它的成员函数（如 add, remove, print）的定义要能够在包含 "OnewayLinkedList.h" 的任何文件中可见。做法是直接在 "OnewayLinkedList.h" 文件中实现这些函数，或者你可以将实现放在另一个文件中（例如 "OnewayLinkedList-impl.h"），然后在 "OnewayLinkedList.h" 文件的末尾包含这个实现文件。

例子展示了如何在头文件中实现模板类的成员函数：

// OnewayLinkedList.h
#pragma once
#include "LinkedListNode.h"

template <class T>
class OnewayLinkedList
{
private:
    LinkedListNode<T>* head; // 指向链表头部指针
    LinkedListNode<T>* tail; // 指向链表尾部指针

public:
    OnewayLinkedList() :head(nullptr), tail(nullptr) {}
    ~OnewayLinkedList() {
        // 适当的析构代码
    }
    void add(T data) {
        // 实现代码
    }
    void remove(T data) {
        // 实现代码
    }
    void print() const {
        // 实现代码
    }
};

此外，还要注意一些其他问题：

1. 在 ~OnewayLinkedList() 析构函数中，你要正确删除链表中的所有节点。当前的代码只删除了头尾节点，可能会造成内存泄漏。你要遍历整个链表并删除每个节点。

2. 在 LinkedListNode 的析构函数中，你直接删除了 next，这可能会导致整个链表的删除。如果你在 OnewayLinkedList 的 remove 函数中删除一个节点，它将递归删除所有后续节点。你要在 remove 函数中更改逻辑，以避免这种情况。

3. 模板类的所有实现都应该放在头文件中，否则在编译时可能会出现链接错误。

4. 确保所有文件都有正确的 #include 指令，并且文件路径也是正确的。

调整这些问题后，你的代码应该能够正确编译和工作。