1.手动封装一个顺序表（SeqList）,分文件编译实现，包含如下：

有私有成员：顺序表数组的起始地址 ptr、 顺序表的总长度：size、顺序表的实际长度：len

成员函数：初始化 init(int n)

判空：empty

判满：full

尾插：push_back

插入：insert（int index）

任意位置删除：erase(int index)

尾删: pop_back

求长度：size（）

获取任意位置元素：& at(int inex)

将顺序表进行排序：sort（bool flag） //flag 为真，表示升序，否则是降序

主函数

#include <iostream>
#include <string.h>
#include "list.h"
int main()
{
    Seqlist list;
    list.init(6);
    list.push_back(1);
    list.push_back(4);
    list.push_back(5);
    list.push_back(2);
    list.push_back(7);
    list.show();
    cout<<"插入："<<endl;
    list.insert(2,9);
    list.show();
    cout<<"删除："<<endl;
    list.erase(2);
    list.show();
    cout<<"尾删："<<endl;
    list.pop_back();
    list.show();

    cout<<"当前大小："<<ends;
    cout<<list.at(2)<<endl;

    cout<<"排序后："<<endl;
    list.sort(1);
    list.show();
    return 0;
}

list.h

#ifndef LIST_H
#define LIST_H


using namespace std;



//封装顺序表

class Seqlist
{
private:
    int *ptr;
    int size;
    int len=0;

public:
    void init(int n);

    bool empty();

    bool full();

    void push_back(int e);//尾插

    void insert(int index,int num);
    //任意位置删除
    void erase(int index);
    //尾删
    void pop_back();

    void show();
    //当前长度
    int cur_size();
    int at(int index);
    void sort(bool flag);

};

#endif // LIST_H

list.c

#include "list.h"
#include <iostream>

using namespace std;



//封装顺序表

void Seqlist::init(int n)
{
    //堆区申请空间（大小为n）
    this->ptr=new int[n];
    //bzero(this->ptr,sizeof(int)*n);


    this->len=0;
    this->size=n;
    //
}
//判空
bool Seqlist::empty()
{
    return this->len==0;
}
bool Seqlist::full()
{
    return this->len==this->size;
}

void Seqlist::push_back(int e)//尾插
{
    if(this->full())
    {
        return ;
    }
    this->ptr[len++]=e;
}
//插入
void Seqlist::insert(int index,int num)
{
    if(full())
    {
        return;
    }
    for(int i=len-1;i>=index-1;i--)
    {
        ptr[i+1]=ptr[i];
    }

    ptr[index-1]=num;
    len++;
}
//任意位置删除
void Seqlist::erase(int index)
{
    if(empty())
    {
        return;
    }
    for(int i=index;i<len;i++)
    {
        ptr[i-1]=ptr[i];
        ptr[i]=NULL;
    }
    len--;
}
//尾删
void Seqlist::pop_back()
{
    if(empty())
    {
        return;
    }
    ptr[len-1]=NULL;
    len--;

}


void Seqlist::show()
{//判空
    if(len==0)
    {
        return;
    }

    cout<<"顺序表"<<endl;
    for(int i=0;i<len;i++)
    {
        cout<<ptr[i]<<ends;
    }

    cout<<endl;
}
//当前长度
int Seqlist::cur_size()
{
    if(empty())
    {
        return 0;
    }
    else
    {
        return len;
    }
}

int Seqlist::at(int index)
{
    int num;
    num=ptr[index-1];
    return num;
}

void Seqlist::sort(bool flag)
{
    if(flag)
    {
        for(int i=1;i<len;i++)
        {
            for(int j=0;j<len-i;j++)
            {
                if(ptr[j]>ptr[j+1])
                {
                    int temp;
                    temp=ptr[j];
                    ptr[j]=ptr[j+1];
                    ptr[j+1]=temp;
                }
            }
        }
    }
    else
    {
        for(int i=1;i<len;i++)
        {
            for(int j=0;j<len-i;j++)
            {
                if(ptr[j]<ptr[j+1])
                {
                    int temp;
                    temp=ptr[j];
                    ptr[j]=ptr[j+1];
                    ptr[j+1]=temp;
                }
            }
        }

    }
}