设计一个简单的单向链表类模板List，并进行测试

好的，下面是单向链表类模板 `List` 的设计：

template<typename T>
class List {
private:
    struct Node {
        T data;
        Node* next;
        Node(T d) : data(d), next(nullptr) {}
    };
    Node* head;

public:
    List() : head(nullptr) {}

    void insert(T d) {
        Node* newNode = new Node(d);
        newNode->next = head;
        head = newNode;
    }

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

    ~List() {
        Node* cur = head;
        while (cur) {
            Node* temp = cur;
            cur = cur->next;
            delete temp;
        }
    }
};

这里使用了模板，可以对不同类型的数据进行插入操作和输出操作。类中使用了一个 `Node` 结构体，用于表示链表中的节点。

类中包含以下公共成员函数：

- `List()`：构造函数，初始化链表头节点为 `nullptr`
- `insert(T d)`：插入一个值为 `d` 的节点到链表头部
- `print()`：输出整个链表
- `~List()`：析构函数，释放链表中所有的节点

接下来，我们可以进行简单的测试：

#include <iostream>
using namespace std;

template<typename T>
class List {
private:
    struct Node {
        T data;
        Node* next;
        Node(T d) : data(d), next(nullptr) {}
    };
    Node* head;

public:
    List() : head(nullptr) {}

    void insert(T d) {
        Node* newNode = new Node(d);
        newNode->next = head;
        head = newNode;
    }

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

    ~List() {
        Node* cur = head;
        while (cur) {
            Node* temp = cur;
            cur = cur->next;
            delete temp;
        }
    }
};

int main() {
    List<int> l1;
    l1.insert(3);
    l1.insert(7);
    l1.insert(2);
    l1.print();

    List<double> l2;
    l2.insert(3.14);
    l2.insert(2.71);
    l2.insert(1.618);
    l2.print();

    return 0;
}

这里分别对一个 `int` 类型的链表和一个 `double` 类型的链表进行插入操作和输出操作，输出结果如下：

2 7 3 
1.618 2.71 3.14