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;
}

小弟是初学者，如果哪位大神发现代码中有错误或需要改进的地方，请您指正，只有发现了自己的错误才能进步，谢谢

本文出自 “分享中进步” 博客，请务必保留此出处http://xmwen1.blog.51cto.com/10730069/1748210

c++中的顺序表写法，主要实现（增删查改，构造函数，运算符重载）

原文：http://xmwen1.blog.51cto.com/10730069/1748210