c++中的顺序表写法，主要实现（增删查改，构造函数，运算符重载）
本文的内容主要是，利用c++写出顺序表，并对写出的代码进行测试，
主要实现的功能：实现对顺序表的增删查改，
要写的函数：构造函数，赋值运算符重载，析构函数。在编写代码过程中应注意到深浅拷贝问题。
下面是顺序表的类函数：
#pragma once
#include<iostream>
using namespace std;
typedef int DataType;
class SeqList
{
public:
SeqList();
SeqList(DataType *array, size_t size);
SeqList(const SeqList &s); //现代写法
SeqList &operator=(SeqList s);
~SeqList();
void PushBack(DataType x);
void PopBack();
void PushFount(DataType x);
void PopFount();
void Insert(size_t pos, DataType x);
void Erase(size_t pos);
int Find(DataType x);
void PrintSeqList();
void _CheekCapacity();
private:
DataType *_array;
size_t _size;
size_t _capaci;
};
上面列举了，顺序表类，和其中包含的函数。
接下来介绍这各个函数：
构造函数，有两个（函数重载）：
SeqList::SeqList()
:_array(NULL),
_size(0),
_capaci(0)
{}
SeqList::SeqList(DataType *array, size_t size)
: _array(new DataType[size]),
_size(size),
_capaci(size)
{
memcpy(_array, array, sizeof(DataType)*size);
}
拷贝构造函数：（两个，分别是不同的拷贝方法）
//SeqList::SeqList(const SeqList& s) //传统写法
// :_array(new DataType[s._size]),
// _size(s._size),
// _capaci(s._size)
//{
// memcpy(_array, s._array, sizeof(DataType)*_size);
//}
SeqList::SeqList(const SeqList &s) //现代写法
:_array(NULL)
{
SeqList temp(s._array, s._size);
swap(_array, temp._array);
_size = s._size;
_capaci = s._capaci;
}
赋值运算符重载：（两个，分别是不同的拷贝方法）
SeqList& SeqList::operator=(SeqList s)
{
swap(s._array, _array);
_size = s._size;
_capaci = s._capaci;
//swap(_size,s._size);
//swap(_capaci,s._capaci);
return *this;
}
//SeqList& SeqList::operator=(const SeqList s)
//{
// if (this != &s)
// {
// DataType *temp = new DataType[s._size];
// delete[]_array;
// _array = temp;
// _size = s._size;
// _capaci = s._size;
// memcpy(_array, s._array, sizeof(DataType)*_size);
// }
// return *this;
//}
析构函数：
SeqList::~SeqList()
{
if (_array)
{
delete[] _array;
}
}
检查顺序表容量的函数：
void SeqList::_CheekCapacity()
{
if (_size >= _capaci)
{
_capaci = 2 * _capaci + 3;
_array = (DataType*)realloc(_array, _capaci*sizeof(DataType));
}
}
插入数据函数：（三个，分别是前插、后插、给定位置插入）
void SeqList::PushFount(DataType x)
{
_CheekCapacity();
for (int i = _size; i > 0; i--)
{
_array[i] = _array[i - 1];
}
_array[0] = x;
_size++;
}
void SeqList::PushBack(DataType x)
{
_CheekCapacity();
_array[_size] = x;
_size++;
}
void SeqList::Insert(size_t pos, DataType x)
{
_CheekCapacity();
if (pos<_size)
for (int i = _size; i > _size - pos; i--)
{
_array[i] = _array[i - 1];
}
_array[pos - 1] = x;
_size++;
}
删除数据函数（三个，分别是前删、后删、给定位置删除）
void SeqList::PopFount()
{
if (_size == 0)
{
cout << "空链表" << endl;
}
for (int i = 0; i < _size - 1; i++)
{
_array[i] = _array[i + 1];
}
_size--;
}
void SeqList::PopBack()
{
if (_size > 0)
{
_size--;
}
}
void SeqList::Erase(size_t pos)
{
if (_size == 0)
{
cout << "空链表，无需删除！" << endl;
}
for (int i = pos; i < _size; i++)
{
_array[i - 1] = _array[i];
}
_size--;
}
查找数据（返回此数据在顺序表中的位置）
int SeqList::Find(DataType x)
{
if (_size == 0)
{
cout << "空链表！" << endl;
}
for (int i = 0; i < _size; i++)
{
if (x == _array[i])
{
return i + 1;
}
}
return -1;
}
还有一个函数就是打印链表，此部分是最直接的观察
void SeqList::PrintSeqList()
{
for (int i = 0; i < (int)_size; i++)
cout << _array[i] << " ";
cout << endl;
}
当然还有测试用例，主函数，
#include "SeqLinkList.h"
void Test1() //顺序表测试
{
SeqList s1; //前插
s1.PushBack(1);
s1.PushBack(2);
s1.PushBack(3);
s1.PushBack(4);
//s1.PopBack();
//s1.PopFount();
//s1.PushFount(4);
//s1.PushFount(1);
s1.Insert(3, 5);
//s1.Erase(3);
s1.Insert(3, 6);
cout << "s1 = ";
s1.PrintSeqList();
SeqList s2(s1);
cout << "拷贝构造 s2 = ";
s2.PrintSeqList();
SeqList s3;
s3 = s1;
cout << "赋值运算符重载 s3 = ";
s3.PrintSeqList();
//int let = s1.Find(6);
//cout << "6 是第"<<let <<"个数"<< endl;
}
int main()
{
Test1();
system("pause");
return 0;
}
小弟是初学者，如果哪位大神发现代码中有错误或需要改进的地方，请您指正，只有发现了自己的错误才能进步，谢谢