【C++】---封装顺序表

封装顺序表：c语言的数据结构有：顺序表、链表、栈、队列。这些数据结构我们都需要用到 ，但是在C语言中没有这样的库去供我们使用。但是C++中是有这样的库，也就是STL标准模板库中有一个组件是容器组件，容器组件中有一个顺序容器vector<int>就是来封装顺序表的，这样我们可以不用建立数据结构，可以直接使用这些数据结构。

由于数组是定长的，所以在封装顺序表的时候我们用到了扩容机制：
1、以倍数的形式开辟更大的空间
2、旧数据拷贝到新的空间中
3、旧空间释放
4、指针指向新空间

STL(标准模板库)：

1、容器类（存放元素的数据结构）

（1）vector：矢量容器，针对顺序表的封装

（2）list：双向链表容器

（3）deque：双向队列容器

（4）set：元素的集合

（5）map：映射的集合

（6）stack：栈又称容器适配器，容器适配器的特点

• 没有自己的数据结构和方法
• 限制了底层容器对象的接口，对外提供新特性

（7）queue：队列

C++封装顺序表：模拟实现vector

#include<iostream>

template<typename T>
class Vector
{
public:
	Vector(int size = 2)
	{
		parr = new T[size]();//动态开辟空间
		cursize = 0;
		totalsize = size;
	}

	~Vector()
	{
		delete[] parr;
		parr = NULL;
	}

	//扩容
	void resize()
	{
		T* tmp = new T[totalsize * 2]();//以2倍的形式扩容
		memcpy(tmp, parr, sizeof(T)*totalsize);//旧的数据拷贝到新的空间
		delete[] parr;//释放旧空间
		parr = tmp;//指针指向新空间
		totalsize *= 2;//调整新空间的总大小
	}

	//尾部插入
	void push_back(T val)//cursize
	{
		//第一种方式
	  /*if (full())
		{
			resize();
		}
		parr[cursize++] = val;*/
		//第二种方式
		insert(cursize, val);
	}

	//按位置插入
	void insert(int pos, T val)
	{
		if (pos < 0 || pos > cursize)//插入的位置不合理
		{
			return;
		}
		if (full())//空间满了
		{
			resize();
		}
		for (int i = cursize; i > pos; i--)
		{
			parr[i] = parr[i - 1];
		}
		parr[pos] = val;
		cursize++;
	}

	//尾删
	void pop_back()
	{
		erase(cursize - 1);
	}

	//按位置删除
	void erase(int pos)
	{
		if (pos < 0 || pos >= cursize)
		{
			return;
		}
		for (int i = pos; i < cursize - 1; i++)
		{
			parr[i] = parr[i + 1];
		}
		cursize--;
	}

	void Show()
	{
		for (int i = 0; i < cursize; i++)
		{
			std::cout << parr[i] << " ";
		}
		std::cout << std::endl;
	}

	//判空
	bool empty()
	{
		return cursize == 0;
	}
private:
	bool full()
	{
		return cursize == totalsize;
	}
	T* parr;//只想存储数据的空间
	int cursize;//当前有效元素的个数  
	//当前数组中可插入元素的下标
	int totalsize;//当前的元素总容量
};

int main()
{
	Vector<int> vec;
	for (int i = 0; i < 10; i++)
	{
		vec.push_back(i + 1);
	}
	vec.Show();
	vec.pop_back();
	vec.Show();
	return 0;
}

如果发现有小数点，在调用点改成下述代码

int main()
{
	Vector<int> ivec;
	for (int i = 0; i < 5; i++)
	{
		ivec.push_back(i + 1);
	}
	Vector<double> dvec = ivec;
	Vector<int> ivec2 = ivec;
	return 0;
}

Vector<double> dvec = ivec;这一句代码调用了拷贝构造函数；因此我们需要在类中实现一个拷贝构造函数

//拷贝构造函数
	Vector(const Vector<T>& rhs)
	{
		parr = new T[rhs.totalsize]();//把旧的对象中的元素放在新的对象空间中
		memcpy(parr, rhs.parr, sizeof(T)*totalsize);
		cursize = rhs.cursize;
		totalsize = rhs.totalsize;
	}

但允许上述代码，我们会发现调用失败。因为Vector<double> dvec = ivec;这句要生成的是devc这个类。所以它做的事就是:将ievc这 个容器对象当成实参传递给Vector<double>类型里面的形参rhs。但是ievc是一个Vector<int>类型，所以两个自定义类型，编译器是不能转换的。

因此我们要解决这个问题就必须把拷贝构造函数写成一个模板

template<typename E>
Vector(const Vector<E>& rhs)
{
	parr = new T[rhs.totalsize]();
	for (int i = 0; i < totalsize; i++)
	{
		parr[i] = rhs.parr[i];
	}
	cursize = rhs.cursize;
	totalsize = rhs.totalsize;
}