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

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();
};