1.C语言的一些不足

我们首先看下面用C语言实现栈

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
typedef int StackDateType;
typedef struct Stack
{
	StackDateType* _ps;
	size_t _size;
	size_t _capacity;
}Stack;
void StackInit(Stack* ps)
{
	assert(ps);
	ps->_ps = NULL;
	ps->_size = ps->_capacity = 0;
}
void StackPushBack(Stack* ps, StackDateType val)
{
	assert(ps);
	if (ps->_size == ps->_capacity)
	{
		size_t newcapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		StackDateType* tmp = (StackDateType*)realloc(ps->_ps, sizeof(StackDateType) * newcapacity);
		if (tmp == NULL)
			exit(1);
		ps->_ps = tmp;
		ps->_capacity = newcapacity;
	}
	ps->_ps[ps->_size] = val;
	ps->_size++;
}
void StackDestory(Stack* ps)
{
	assert(ps);
	free(ps->_ps);
	ps->_capacity = ps->_size = 0;
	ps->_ps = NULL;
	
}
int main()
{
	Stack s1;
	StackInit(&s1);
	StackPushBack(&s1, 5);
	StackPushBack(&s1, 6);
	StackPushBack(&s1, 5);
	StackPushBack(&s1, 1);
	StackPushBack(&s1, 9);
	StackPushBack(&s1, 6);

	StackDestory(&s1);
	return 0;
}

这是我们简单的实现的一个栈，可以发现其弊端：

①如果忘记初始化，就会造成程死循环，如果忘记destroy就会导致空间泄漏

②我们可以随意修改栈中的数据

③不能同时定义两种类型的栈，一种存int数据，一种存double数据

2.C++的改进

C++就从这三方面的不足做出来改进

针对①：C++中引入了类，实例化类时会自动调用构造函数，类销毁后会自动调用析构函数

针对②：C++引入了类+类中的访问限定符

针对③：C++引入了模版，实现了泛型编程，即可以定义与类型无关的类或者函数。

下面我们有C++代码实现Stack，这时我们就很好的解决了以上的问题，这也是c发展到c++的一大步

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

template<class T>
class Stack
{
public:
	Stack()//定义构造函数
		:_arr(nullptr)
		,_size(0)
		,_capacity(0)
	{}
	~Stack()//定义析构函数
	{
		assert(_arr);
		delete[]_arr;
		_arr = nullptr;
		_size = _capacity = 0;
	}
	void StackPushBack(const T& x)
	{
		if (_size == _capacity)
		{
			size_t newcapacity = _capacity == 0 ? 4 : 2 * _capacity;
			T* tmp = new T[newcapacity];
			if (_arr)
			{
				memcpy(tmp, _arr, _size * sizeof(T));
				delete[]_arr;
			}
			_arr = tmp;
			_capacity = newcapacity;
		}//实现扩容
		_arr[_size++] = x;
	}
private:
	T* _arr;
	size_t _size;
	size_t _capacity;
};


int main()
{
	Stack<int> s1;
	s1.StackPushBack(1);
	Stack<double> s2;
	s2.StackPushBack(1.25);
	return 0;

}