很像数组，只是把简单的元素换为用户自己定义的结构体，感觉像是对数组的一个扩展；

声明一个线性表事先要为其分配一个较大的固定的连续的存储空间，这样就造成内存浪费或者是内存不足，很多时候是内存浪费；

因为线性表和数组很相似，所以就继承了数组的一些优点，根据下标可以定向找到一个目标；

写一个简单的线性表：

    #include<stdio.h>  
    #include<malloc.h>  
    #define M 10000  
    typedef struct Xian  
    {  
        int *ap;//数据段  
        int length;//表的长度  
    }jie;  
    void Initialization(jie* p)//初始化表   
    {  
        p->ap=new int[M];  
        //p->ap=(int *)malloc(sizeof(int)*M);  
        p->length=0;  
    }  
    bool Empty(jie* p)//判断表空  
    {  
        if(p->length==0)  
            return true;  
        return false;  
    }  
    bool Full(jie* p)   //判断表是否已满  
    {  
        if(p->length==M-1)  
            return true;  
        return false;  
    }  
    void Add(jie* p)   //添加  
    {  
        if(Full(p))  
        {  
            printf("内存已满\n");  
            return;  
        }  
        int a;  
        scanf("%d",&a);  
        p->ap[p->length]=a;  
        p->length++;  
    }  
    void Insert(jie* p,int index,int e)  //插入  
    {  
        if(Full(p))  
        {  
            printf("内存已满\n");  
            return;  
        }  
        if(index>p->length)  
        {  
            p->ap[p->length]=e;  
            p->length++;  
            return;  
        }  
        else  
        {  
            for(int i=p->length-1;i>index;--i)  
                p->ap[i+1]=p->ap[i];  
            p->ap[index-1]=e;  
            p->length++;  
            return ;  
        }  
    }  
    void Delet(jie* p,int index) // 删除  
    {  
        if(index>p->length||index<1)  
            return;  
        else  
        {  
            for(int i=index-1;i<p->length;++i)  
                p->ap[i]=p->ap[i+1];  
            p->length--;  
        }  
    }  
    int *Search(jie* p,int index)//查找  
    {  
        if(index<1||index>p->length)  
            return NULL;  
        else  
        {  
            for(int i=0;i<p->length;++i)  
            {  
                if(i==index-1)  
                    return &p->ap[index-1];  
            }  
        }  
    }  
    void PutAll(jie* p)   //输出所有数据  
    {  
        for(int i=0;i<p->length;++i)  
            printf("%d\n",p->ap[i]);  
    }  
    void Destroy(jie* p)//摧毁线性表  
    {  
        p->length=0;  
        delete p->ap;  
        //free(p->ap);  
    }  
    int main()  
    {  
        jie* pos;  
        pos=new jie;    //为指针分配内存  
        Initialization(pos);  
        Add(pos);  
        Add(pos);  
        Add(pos);  
        Insert(pos,2,9);  
        Delet(pos,4);  
        PutAll(pos);  
        return 0;  
    }  

写了线性表的常见功能，还有很多可以自己发挥，

这里用到了指针，不过在有些高级语言中没有指针这个东西；

这里就要用引用来实现了；

这里就举个例子看引用如何实现；

    #include<iostream>  
    int main(){  
        int i=5;  
        int &j=i; //为i取了一个别名j，相当于i和j是指的同一个变量；  
        i=7;  
        cout<<"i="<<i<<" j="<<j;  
    }  

于是我们发现引用能够达到指针传参的效果，

其实这里如果对传参的副本机制有所了解的话理解起来可能会更加清晰；

用引用改写上面的代码：

    #include<stdio.h>  
    #include<malloc.h>  
    #define M 10000  
    typedef struct Xian  
    {  
        int *ap;//数据段  
        int length;//表的长度  
    }jie;  
    void Initialization(jie &p)//初始化表   
    {  
        p.ap=new int[M];  
        //p->ap=(int *)malloc(sizeof(int)*M);  
        p.length=0;  
    }  
    bool Empty(jie &p)//判断表空  
    {  
        if(p.length==0)  
            return true;  
        return false;  
    }  
    bool Full(jie &p)   //判断表是否已满  
    {  
        if(p.length==M-1)  
            return true;  
        return false;  
    }  
    void Add(jie &p)   //添加  
    {  
        if(Full(p))  
        {  
            printf("内存已满\n");  
            return;  
        }  
        int a;  
        scanf("%d",&a);  
        p.ap[p.length]=a;  
        p.length++;  
    }  
    void Insert(jie &p,int index,int e)  //插入  
    {  
        if(Full(p))  
        {  
            printf("内存已满\n");  
            return;  
        }  
        if(index>p.length)  
        {  
            p.ap[p.length]=e;  
            p.length++;  
            return;  
        }  
        else  
        {  
            for(int i=p.length-1;i>index;--i)  
                p.ap[i+1]=p.ap[i];  
            p.ap[index-1]=e;  
            p.length++;  
            return ;  
        }  
    }  
    void Delet(jie &p,int index) // 删除  
    {  
        if(index>p.length||index<1)  
            return;  
        else  
        {  
            for(int i=index-1;i<p.length;++i)  
                p.ap[i]=p.ap[i+1];  
            p.length--;  
        }  
    }  
    int *Search(jie &p,int index)//查找  
    {  
        if(index<1||index>p.length)  
            return NULL;  
        else  
        {  
            for(int i=0;i<p.length;++i)  
            {  
                if(i==index-1)  
                    return &p.ap[index-1];  
            }  
        }  
    }  
    void PutAll(jie &p)   //输出所有数据  
    {  
        for(int i=0;i<p.length;++i)  
            printf("%d\n",p.ap[i]);  
    }  
    void Destroy(jie &p)//摧毁线性表  
    {  
        p.length=0;  
        delete p.ap;  
        //free(p->ap);  
    }  
    int main()  
    {  
        jie pos;  
        Initialization(pos);  
        Add(pos);  
        Add(pos);  
        Add(pos);  
        Insert(pos,2,9);  
        Delet(pos,4);  
        PutAll(pos);  
        return 0;  
    }