c++ - 如何将列表类转换为模板，以便它可以处理任何数据？

Question

如何将列表类转换为模板化链接类，以便它可以处理任何数据。下面是一个处理整数的类。我想将它转换为模板化类，以便它适用于任何数据类型

#ifndef _INTLIST_H_
#define _INTLIST_H_
#include <iostream>
class IntListNode
{
    protected:
        int value;
    public:
        IntListNode* nxt;
        IntListNode(int = 0, IntListNode* = NULL);
        IntListNode(const IntListNode&);
        IntListNode& operator=(const IntListNode&);
        int val() const;
        void val(int);
        IntListNode* next() const;
};

class IntList
{
    protected:
        IntListNode* nhead;
        IntListNode* tail;
        int csize;
    public:
        IntList();
        IntList(const IntList&);
        IntList& operator=(const IntList&);
        int size() const;
        IntListNode* head() const;
        void push(int);
        void pop();
        void clear();
        ~IntList();
};

#endif

这是我做的

#ifndef _INTLIST_H_
#define _INTLIST_H_
#include <iostream>

template <class T>
class IntListNode
{
    protected:
        T value;
    public:
        IntListNode* nxt;
        IntListNode(int = 0, IntListNode* = NULL);
        IntListNode(const IntListNode&);
        IntListNode& operator=(const IntListNode&);
        T val() const;
        void val(T);
        IntListNode* next() const;
};


template <class T>
class IntList
{
    protected:
        IntListNode<T> nhead;
        IntListNode<T>tail;
        int csize;
    public:
        IntList();
        IntList(const IntList&);
        IntList& operator=(const IntList&);
        int size() const;
        IntListNode* head() const;
        void push(T);
        void pop();
        void clear();
        ~IntList();
};

#endif

Answer 1

1. 更改 IntLisNode至 ListNode并将其设为类模板。
2. 更改 IntLis至 List并使它成为一个类模板。使用 ListNode<T>在List而不是 IntListNode .
3. 替换使用 int通过 T在某些地方和 T const&在函数签名中。

这是一个快速改造。

#ifndef _LIST_H_
#define _LIST_H_
#include <iostream>

template <typename T>
class ListNode
{
    protected:
        T value;
    public:
        ListNode* nxt;
        ListNode(T const& in, ListNode* = NULL);
        ListNode(const ListNode&);
        ListNode& operator=(const ListNode&);
        T const& val() const;
        void val(T const&);
        ListNode* next() const;
};

template <typename T>
class List
{
    protected:
        ListNode<T>* nhead;
        ListNode<T>* tail;
        int csize;
    public:
        List();
        List(const List&);
        List& operator=(const List&);
        int size() const;
        ListNode<T>* head() const;
        void push(T const& val);
        void pop();
        void clear();
        ~List();
};