C++实现顺序表

头文件seqlist.h

#pragma once

#include<iostream>
#include<assert.h>
using namespace std;

typedef int DataType; 
class SeqList 
{ 
public: 
    SeqList() 
        : _array(new DataType[3]) 
        , _capacity(3) 
        , _size(0) 
    {} 


    SeqList(DataType* array, size_t size)
        : _array(new DataType[size]) 
        , _capacity(size) 
        , _size(size) 
    { 
        for(size_t i = 0; i < size; ++i) 
            _array[i] = array[i]; 
    }

    SeqList(const SeqList& s); 
    SeqList& operator=(const SeqList& s); 
    ~SeqList() 
    { 
        if(_array) 
        { 
            delete[] _array; 
            _size = 0; 
            _capacity = 0; 
        } 
    } 

    void PrintList();//打印顺序表
    void PushBack(int data); //尾插
    void PopBack(); //尾删
    void Insert(size_t pos, DataType data); //指定位置插入
    void Erase(size_t pos); //删除指定元素
    size_t Size()const; //统计元素个数
    size_t Capacity()const; //计算容量
    bool Empty()const; //判断顺序表是否为空
    DataType& operator[](size_t index); //[]重载
    const DataType& operator[](size_t index)const; 

    // 返回顺序表中的第一个元素 
    DataType& Front(); 
    const DataType& Front()const; 
    // 返回顺序表中最后一个元素 
    DataType& Back(); 
    const DataType& Back()const; 

    // 清空顺序表中的所有元素 
    void Clear(); 


private: 
    void _CheckCapacity(); 
private: 
    DataType* _array; 
    size_t _size; 
    size_t _capacity; 
}; 

函数实现seqlist.cpp

#include "seqlist.h"

void SeqList::PrintList()//打印顺序表
{
    for( size_t i=0; i<_size; i++)
        cout<<_array[i]<<" ";
    cout<<endl;
}
SeqList::SeqList(const SeqList& s)
{
    //开辟空间，赋值
    _array = new DataType[s._capacity];
    _size  = s._size;
    _capacity =s._capacity;

    //拷贝数据
    for( size_t i=0; i<_size; i++)
    {
        _array[i] = s._array[i];
    }
}

SeqList& SeqList::operator=(const SeqList& s)
{
    //赋值，释放旧空间
    _size = s._size;
    _capacity = s._capacity;
    delete[] _array;

    //开辟新空间，拷贝数据
    _array = new DataType[_capacity];
    for( size_t i=0; i<_size; i++)
    {
        _array[i] = s._array[i];
    }
    return *this;
}
void SeqList::_CheckCapacity()
{
    //容量未满，退出
    if( _size < _capacity)
        return;

    //扩容
    //增加_capacity,开辟新空间,拷贝数据
    _capacity+=3;
    DataType* new_array = new DataType[_capacity];
    for( size_t i=0; i<_size; i++)
    {
        new_array[i] = _array[i];
    }


    //释放旧空间，让_array指向新空间
    delete[] _array;
    _array = new_array;

}
void SeqList::PushBack(int data) //尾插
{
    //检查容量
    _CheckCapacity();

    //赋值,_size加一
    _array[_size] = data;
    _size++;
}
void SeqList::PopBack() //尾删
{
    //空
    if( 0 == _size)
        return;

    //非空
    _size--;

}

void SeqList::Insert(size_t pos, DataType data) //指定位置插入
{
    //检查pos是否合法
    if( pos>_size) //因为pos是无符号数不存在小于0的情况
        return;    //所以下标不大于_size 就合法

    //检查容量
    _CheckCapacity();

    //插入,从后往前将pos以后数据全部往后挪动一格，给pos处赋值，_size++
    for( size_t i=_size; i>pos; i--)
    {
        _array[i] = _array[i-1];
    }
    _array[pos] = data;
    _size++;
}

void SeqList::Erase(size_t pos)//删除指定位置元素
{
    //检查pos是否合法
    if( pos >=_size)
        return;

    //pos以后每个元素往前挪动一格，_size--
    for( size_t i=pos; i<_size-1; i++)
    {
        _array[i] = _array[i+1];
    }
    _size--;
}

size_t SeqList::Size()const//统计元素个数
{
    return _size;
}
size_t SeqList::Capacity()const//计算容量
{
    return _capacity;
}
bool SeqList::Empty()const//判断顺序表是否为空
{
    return 0 == _size;
}
DataType& SeqList::operator[](size_t index)//[]重载
{
    //非法下标处理
    assert( index<_size);

    //返回
    return _array[index];
}
const DataType& SeqList::operator[](size_t index)const
{   
    //非法下标处理
    assert( index<_size);

    //返回
    return _array[index];
}
DataType& SeqList::Front()//返回顺序表中的第一个元素
{
    //顺序表不能为空
    assert( 0!=_size );

    //返回第一个元素
    return _array[0];
}
const DataType& SeqList::Front()const
{   
    //顺序表不能为空
    assert( 0!=_size );

    //返回第一个元素
    return _array[0];
}
DataType& SeqList::Back()//返回顺序表中的最后一个元素
{
    //顺序表不能为空
    assert( 0!=_size );

    //返回最后一个元素
    return _array[_size-1];
}
const DataType& SeqList::Back()const
{
    //顺序表不能为空
    assert( 0!=_size );

    //返回最后一个元素
    return _array[_size-1];
}
void SeqList::Clear()//清空顺序表中所有元素 
{
    _size = 0;
}

测试代码test.cpp

#include "seqlist.h"

int main()
{
    //SeqList s1;
    //s1.PushBack(1);
    //s1.PushBack(2);
    //s1.PopBack();
    //s1.PushBack(3);
    //s1.PushBack(4);
    //s1.PrintList();

    //SeqList s2(s1);
    //s2.PrintList();

    //s1.PushBack(5);
    //s1.PushBack(6);
    //s2 = s1;
    //s2.PrintList();

    SeqList s;
    //s.PushBack(1);
    //s.PushBack(2);
    //s.PushBack(3);
    //s.PrintList();

    //s.PopBack();
    //s.PrintList();
    //s.PopBack();
    //s.PrintList();
    //s.PopBack();
    //s.PrintList();
    //s.PopBack();
    //s.PrintList();

    //s.PushBack(0);
    //s.PushBack(1);
    //s.PushBack(2);
    //s.PushBack(3);

    //s.Insert(2,11);
    //s.PrintList();

    //s.Insert(5,12);
    //s.PrintList();

    //s.Insert(0,13);
    //s.PrintList();

    //s.Insert(-1,14);
    //s.PrintList();

    //s.Insert(8,15);
    //s.PrintList();

    //cout<<s.Empty()<<endl;
    //cout<<s.Size()<<endl;
    //cout<<s.Capacity()<<endl;
    //cout<<endl;

    //s.PushBack(1);
    //s.PrintList();
    //cout<<s.Empty()<<endl;
    //cout<<s.Size()<<endl;
    //cout<<s.Capacity()<<endl;
    //cout<<endl;

    //s.PushBack(2);
    //s.PrintList();
    //cout<<s.Empty()<<endl;
    //cout<<s.Size()<<endl;
    //cout<<s.Capacity()<<endl;
    //cout<<endl;

    //s.PushBack(3);
    //s.PrintList();
    //cout<<s.Empty()<<endl;
    //cout<<s.Size()<<endl;
    //cout<<s.Capacity()<<endl;
    //cout<<endl;

    //s.PushBack(4);
    //s.PrintList();
    //cout<<s.Empty()<<endl;
    //cout<<s.Size()<<endl;
    //cout<<s.Capacity()<<endl;
    //cout<<endl;


    s.PushBack(1);
    s.PushBack(2);
    s.PushBack(3);
    s.PushBack(4);
    //cout<<s[0]<<endl;
    //cout<<s[3]<<endl;

    cout<<s.Front()<<endl;
    cout<<s.Back()<<endl;

    s.Clear();
    s.PrintList();
    cout<<s.Empty();



    return 0;
}