C++单链表

在单链表中保存一些整数ID，列表的每个结点包含ID及指向下一个结点的指向。
单链表中最后一个结点的指针域为null（0）。一个null指针不是有效的指针，不能反引用，但可以检查它是否为0（例如：p==0)

List.h单链表类

//链接（结点）
class Link
{
public:
    Link(Link* pNext, int id) : _pNext(pNext), _id(id){}
    Link* Next()const{  return _pNext;}
    int Id()const{  return _id;}
private:
    Link* _pNext;
    int _id;
};
//链表
class List
{
public:
    //初始化时头指针指向NULL
    List() :_pHead(0){}
    ~List();
    //在第一个元素前插入
    void Add(int id);
    Link const *GetHead()const{ return _pHead;}
private:
    //头指针
    Link* _pHead;
};

List.cpp

#include"List.h"
void List::Add(int id)
{
    //新的结点，新结点的指针域指向头结点指向的结点
    Link* pLink = new Link(_pHead, id);
    //头指针指向新的结点
    _pHead = pLink;
}
//释放链表内存
List::~List()
{
    while (_pHead != 0)
    {
        Link* pLinkTmp = _pHead;
        _pHead = _pHead->Next();
        delete pLinkTmp;
    }
}

main.cpp

#include"List.h"
#include<iostream>
int main()
{
    List myList;
    for (int i = 0; i < 10; i++)
    {
        myList.Add(i);
    }
    //寻找id等于给定值的结点
    for (Link const* pLink = myList.GetHead();
        pLink != 0;
        pLink = pLink->Next())
    {
        if (pLink->Id() == 5)
        {
            std::cout << "Find " << 5 << std::endl;
            break;
        }
        std::cout << "Current id is" << pLink->Id() << std::endl;
    }
}

额外
指针常量与常量指针
（1）指针常量
指针本身是一个常量，不能修改指针本身，但可以修改指针指向的内容。因此是常量，所以必须初始化。

int a=10;
int b=20;
int * const p=&a;
*p=20;
//p=&b;(错误，不可以修改指针本身)

(2)常量指针
指向常量的指针，称为常量指针。指针本身可以修改，但指针指向的内容不可以修改。

int a=10;
int b=20;
int * const p=&a;
//*p=20;（错误，指针指向的内容不可修改）
p=&b;

(3)指向常量的指针常量
指向常量的指针常量，指针本身，指针指向内容，都不可以修改。初始化后，就是一个固定的值。

int a=10;
int const * const p=&a;

int a=10;
int b=20;
int const *p1=&a;
int * const p2=&b;
p1=&b;
*p2=a;
std::cout<<*p1<<std::endl;//输出10
std::cout<<*p2<<std::endl;//输出10

从右至左读变量声明
(1)int const * p;
p是一个指针，指向常量int。
(2)int * const p;
p是一个指针常量，指向int。
(3)int const * const p;
p是一个指针常量，指向常量int。
可以把* const看作一个内容，读作指针常量。
一种理解有关指针的变量声明的方法
int *p
将其看成 int(*p)，p是一个指针，*p是一个int，所以p是一个指向int的指针。
int *const p
看成 int (*const p)，p是一个指针常量，*p是一个int，所以p是一个指向int的指针常量。
int（*p）fun()
p是一个指针，*p是一个int fun（），p是一个指向函数的指针。
int *p[4]
看成 int (*p[4])，p是一个指针数组，*p是一个int，所以p是int类型的指针数组。
int（*p）[4]
p是一个指针，*p是int[4]，所以p是一个指针数组的指针。
PS：常量指针外文为 pointer to const，指针常量外文为 const pointer，感觉还是翻译后更难懂。