用C++的方式去封装一个动态顺序表;在前面我们说过动态顺序表这种数据结构
动态顺序表入口:https://blog.csdn.net/LSFAN0213/article/details/81264576
下来直接上代码:
#pragma once
#include <iostream>
#include <assert.h>
using namespace std;
typedef int DataType;
class MyVector
{
public:
//构造空MyVector
MyVector()
//初始化列表
: _array(new DataType[3])
, _Capacity(3)
, _size(0)
{}
//带参数的构造函数
MyVector(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];
}
//参数为两个区间的构造函数,用[first,last]区间构造MyVector
MyVector(DataType* first, DataType* last)
{
size_t size = last - first;
_array = new DataType(size);
_Capacity = size;
_size = size;
for (size_t i = 0; i < size; ++i){
_array[i] = first[i];
}
}
//拷贝构造函数
MyVector(const MyVector& v)
{
_array = new DataType[v._size];
_Capacity = v._size;
_size = v._size;
for (size_t i = 0; i < v._size; ++i)
_array[i] = v._array[i];
}
//赋值运算符重载
MyVector operator=(const MyVector& v)
{
if (this != &v){
DataType *Tmp = _array;
_array = new DataType(v._Capacity);
_size = v._size;
_Capacity = v._Capacity;
delete[] Tmp;
size_t i = 0;
for (i = 0; i < v._size; ++i){
_array[i] = v._array[i];
}
}
return *this;
}
//析构函数
~MyVector()
{
if (_array){
delete[] _array;
_array = NULL;
_Capacity = 0;
_size = 0;
}
}
//运算符重载
DataType& operator[](size_t index)const
{
assert(index < _size);
return _array[index];
}
//获取MyVector中的第一个元素
DataType& Front()
{
return _array[0];
}
const DataType& Front()const
{
return _array[0];
}
//获取MyVector中的最后一个元素
DataType& Back()
{
return _array[_size - 1];
}
const DataType& Back()const
{
return _array[_size - 1];
}
//获取MyVector的大小
size_t Size()const
{
return _size;
}
//获取MyVector的容量
size_t Capacity()const
{
return _Capacity;
}
//重置MyVector的大小
void ReSize(size_t newSize, const DataType& data = DataType())
{
size_t oldSize = Size();
if (newSize <= oldSize)
_size = newSize;
else{
if (newSize <= _Capacity){
for (size_t i = oldSize; i < newSize; ++i)
_array[i] = data;
}
else{
DataType* pTemp = new DataType[newSize];
for (size_t i = 0; i < oldSize; ++i)
pTemp[i] = data;
delete[] _array;
_array = pTemp;
_Capacity = newSize;
_size = newSize;
}
}
}
void Reserve(size_t newCapacity)
{
size_t oldCapacity = Capacity();
if (newCapacity > oldCapacity){
DataType* pTemp = new DataType[newCapacity];
for (size_t i = 0; i < Size(); ++i)
pTemp[i] = _array[i];
delete[] _array;
_array = pTemp;
_Capacity = newCapacity;
}
}
//尾插
void PushBack(const DataType& data)
{
_CheckCapacity();
_array[_size++] = data;
}
//尾删
void PopBack()
{
--_size;
}
//按下标插入
void Insert(size_t pos, const DataType& data)
{
if (pos > _size){
return;
}
_CheckCapacity();
for (size_t i = _size - 1; i >= pos; i--)
_array[pos] = data;
++_size;
}
//按下标删除
void Erase(size_t pos)
{
if (pos >= _size){
return;
}
for (size_t i = pos; i < _size - 1; ++i)
_array[i] = _array[i + 1];
--_size;
}
//清空
void Clear()
{
_size = 0;
}
private:
friend ostream& operator<<(ostream& _cout, const MyVector& v)
{
for (size_t i = 0; i < v._size; ++i){
cout << v._array[i] << " ";
}
return _cout;
}
private:
//检查是否需要扩容
void _CheckCapacity()
{
if (_size == _Capacity){
Reserve(_Capacity * 2);
}
}
DataType* _array;
size_t _size;
size_t _Capacity;
};
//测试函数
void Test()
{
int array[] = { 1, 2, 3, 4, 5 };
MyVector m1(array, sizeof(array) / sizeof(array[0]));
m1.PushBack(6);
cout << m1 << endl;
cout << m1.Size() << endl;
cout << m1.Capacity() << endl;
m1.ReSize(10);
cout << m1 << endl;
cout << m1.Size() << endl;
cout << m1.Capacity() << endl;
m1.PopBack();
cout << m1 << endl;
cout << m1.Size() << endl;
cout << m1.Capacity() << endl;
m1.ReSize(2);
cout << m1 << endl;
cout << m1.Size() << endl;
cout << m1.Capacity() << endl;
}
int main()
{
Test();
return 0;
}
运行结果图: