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