c++ 顺序表

seqence_list.h

#pragma once

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

typedef int DataType;

class SeqList
{
public:
    SeqList()
        :_array((DataType*)malloc(sizeof(DataType)*4))
        , _size(0)
        , _capacity(4)
    {}

    SeqList(const SeqList& s)
        :_array((DataType*)malloc(s._capacity * 4))
        ,_size(s._size)
        , _capacity(s._capacity)
    {
        for (int i = 0; i < _size; ++i)
        {
            _array[i] = s._array[i];
        }

    SeqList& operator=(SeqList s)
    {
        if (_array != s._array)
        {
            SeqList stmp(s);
            Swap(stmp);
        }
        return *this;
    }

    ~SeqList()
    {
        free(_array);
    }

    void Swap(SeqList& s);
    void PushBack(DataType x);
    void PopBack();
    void PushFront(DataType x);
    void PopFront();
    void Insert(size_t pos, DataType x);
    void Erase(size_t pos);
    DataType& operator[](size_t pos);
    void CheckCapcacity();
    void Print();
private:
    DataType* _array;
    size_t _size;
    size_t _capacity;
};

seqence_list.cpp

#define _CRT_SECURE_NO_WARNINGS 1

#include "sequence_list.h"

void SeqList::Swap(SeqList& s)
{
    swap(_array, s._array);
    swap(_size, s._size);
    swap(_capacity, s._capacity);
}

void SeqList::PushBack(DataType x)
{
    CheckCapcacity();

    _array[_size++] = x;
}
void SeqList::PopBack()
{
    if (_size != 0)
    {
        _size--;
        _array[_size] = 0;
    }
}

void SeqList::PushFront(DataType x)
{
    CheckCapcacity();

    for (int i = _size; i > 0; i--)
    {
        _array[i] = _array[i - 1];
    }
    _array[0] = x;
    _size++;
}

void SeqList::PopFront()
{
    for (int i = _size; i > 0; i--)
    {
        _array[i-1] = _array[i];
    }
    _size--;
}

void SeqList::Insert(size_t pos, DataType x)
{
    assert(pos <= _size);
    CheckCapcacity();

    for (int i = _size; i > pos; i--)
    {
        _array[i] = _array[i - 1];
    }
    _array[pos] = x;
    _size++;
}

void SeqList::Erase(size_t pos)
{
    if (pos < _size)
    {
        for (int i = pos; i < _size; i++)
        {
            _array[i] = _array[i + 1];
        }
        _size--;
    }
}

DataType& SeqList::operator[](size_t pos)
{
    assert(pos < _size);
    return _array[pos];
}

inline void SeqList::CheckCapcacity()
{
    if (_size == _capacity)
    {
        _array = (DataType*)realloc(_array, (sizeof(DataType))*(_capacity += 4));
    }
    assert(_array != NULL);
}

void SeqList::Print()
{
    if (_size != 0)
    {
        for (int i = 0; i < _size; i++)
            cout << _array[i] << ' ';
        cout << endl;
    }
    else
        cout << "no data" << endl;
}