以链表为载体学习C++（4）

这是一个系列的文章，主要目的是让初学者掌握链表的实现方法，并且从C过渡到C++。

作者：重庆工程职业技术学院 万青

第3篇文章中，add、insert方法的参数变成了指针，假设所有类的基类是Object，那么该指针是可以指向任何对象的。也就是说，链表节点可以容纳任意类型的数据（当然只是存了一个首地址）。

不过更彻底的解决办法是用模板类：

#include<iostream>
using namespace std;
template<class T> 
class CNode //节点类
{
    public:
        T data;
        CNode *next;
        CNode(T d) //构造函数
        {
            data=d;
            next=NULL;
        }
};
template<class T> 
class CList //链表类
{
    private:
        CNode<T> *head,*tail; //头、尾节点对象指针
        int length; //节点总数
    public:
        CList(); //构造函数(创建链表对象，并创建头节点，初始化头、尾指针等)
        void add(T data); //添加值为data的节点到链表末尾
        int insert(T data,int idx); //将数据data插入到链表的idx位置之后
        int del(int idx); //删除链表中的第idx个节点(idx从1开始计)
        CNode<T> * getPointerByIndex(int idx);//获取第idx个节点的对象指针(idx从1开始计)
        T* toArray(); //显示(遍历)链表的所有节点
        int getLength()
        {
            return length;
        }
        ~CList(); //析构函数(清除链表中的所有节点对象)
};

template<class T> 
CList<T>::CList()
{
    head=tail=new CNode<T>(0);
    length=0;
}

template<class T> 
void CList<T>::add(T data)
{
    CNode<T> *pNode=new CNode<T>(data);
    tail->next=pNode; 
    tail=pNode;//调整尾指针，指向新节点
    length++; //节点总数加1
}

template<class T> 
CNode<T> * CList<T>::getPointerByIndex(int idx)
{
    CNode<T> *p;
    int i=1;
    if(idx<1 || idx>length) return NULL;
    p=head;

    while(i<=idx)
        {
            p=p->next;
            i++;
        }
    return p;
}

template<class T> int CList<T>::insert(T data,int idx)
{
    CNode<T> *p;
    p=getPointerByIndex(idx);
    if(p!=NULL)
    {
        CNode<T> *pNode=new CNode<T>(data);
        pNode->next=p->next;
        p->next=pNode;
        length++;
        return 1; //成功，返回1
    }
    return 0;
}

template<class T> int CList<T>::del(int idx)
{
    CNode<T> *p,*q;
    if(idx<1 || idx>length)
        return 0; //失败，返回0

    //获得要删除节点的前一个节点指针
    if(idx==1) p=head;
    else p=getPointerByIndex(idx);

    //删除p节点的后一节点
    q=p->next; //记住后一节点的指针
    p->next=q->next;
    //delete(q->data);
    delete(q);
    length--;
    return 1;//成功，返回1
}

template<class T> T* CList<T>::toArray()
{
    T *a=new T[length];
    CNode<T> *p;
    p=head;
    for(int i=0;i<length;i++)
    {
        p=p->next; //head节点没有数据，先移动再读取
        a[i]=p->data;
    }
    return a;
}


template<class T> CList<T>::~CList()
{
    CNode<T> *curr,*tmp;
    curr=head;
    for(int i=0;i<=length;i++)
    {
        tmp=curr;
        curr=curr->next;
        //delete(tmp->data);
        delete(tmp);
    }
}

void showList(CList<int> *li)
{
    int *a=li->toArray();
    for(int i=0;i<li->getLength();i++)
        cout<<a[i]<<" ";
    cout<<"\n-------------------\n";
}

void main()
{
    CList<int> *li;
    li=new CList<int>();
    //int a=100,b=101,c=102;
    //li->add(&a);
    //li->add(&b);
    //li->add(&c);
    li->add(100);
    li->add(101);
    li->add(102);
    li->add(103);
    showList(li);
    li->insert(200,2);
    showList(li);
    li->insert(300,3);
    showList(li);
    li->del(1);
    showList(li);
    delete(li);
}

模板类不仅可以用于节点数据是对象指针的场合，也适用于节点数据是基本类型（如int）的场合。在此基础上，看到Java中的LinkedList<T>和C#中的List<T>，就不会有唐突的感觉了。稍微不同的是，Java和C#中去掉了“*”，把“->”变成“.”，对象指针也换了个名字叫“对象句柄”。