標頭檔案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;
}