构造函数和析构函数

一、OOP实现一个顺序栈

#include <iostream>
/*
OOP实现一个顺序栈
*/
class SeqStack
{
public:
	void init(int size = 10)
	{
		_pstack = new int[size];
		_top = -1;
		_size = size;
	}
	void release()
	{
		delete[] _pstack;
		_pstack = nullptr;
	}
	void push(int val)
	{
		if (full())
			resize();
		_pstack[++_top] = val;
		
	}
	void pop()
	{
		if (empty())
			return;
		--_top;
	}
	int top()
	{
		return _pstack[_top];
	}
	bool empty() {
		return _top == -1;
	}
	bool full()
	{
		return _top == _size - 1;
	}
private:
	int* _pstack;//动态开辟数组，存储顺序栈的元素
	int _top;//指像栈顶元素的位置
	int _size;//数据扩容的总大小
	void resize()
	{
		int* ptmp = new int[_size * 2];
		for (int i = 0;i < _size;++i)
		{
			ptmp[i] = _pstack[i];
		}
		delete[] _pstack;
		_pstack = ptmp;
		_size *= 2;
	
	}
};

int main()
{
	SeqStack s;
	s.init(5);//对象成员变量初始化操作
	for (int i = 0;i < 15;++i)
	{
		s.push(rand() % 100);
	}
	while (!s.empty())
	{
		std::cout << s.top() << " ";
		s.pop();
	}
	//s.release();//释放对象成员变量占用的外部堆内存
}

二、为什么需要使用构造函数和析构函数

上述示例中可能忘记s.init方法和s.release()导致栈没有初始化或未释放对象成员变量占用的外部堆内存

使用构造函数和析构函数实现代码

/*
构造函数:
	定义对象时，自动嗲用，可以重载的；构造完成，对象产生
析构函数：
    不带参数，不能重载，只有一个析构函数；析构完成对象就不存在了
.data段上的对象，程序启动时构造,程序结束时析构
heap上的对象，new的时候构造，delete时析构，
stack上的对象，进作用定义处构造，出作用域析构

构造析构顺序：先构造对象后析构，后构造对象先析构   

OOP实现一个顺序栈
*/
class SeqStack
{
public:
	/*
	* 析构函数
	*/
	 SeqStack(int size = 10)//是可以带参数的，因此可以提供多个构造函数
	{
		 std::cout << this << "SeqStack" << std::endl;
		_pstack = new int[size];
		_top = -1;
		_size = size;
	}
	
	 /*
	 * 析构函数
	 */
	~SeqStack()//是不带参数的，所以析构函数只能有一个
	{
		std::cout << this << "~SeqStack" << std::endl;
		delete[] _pstack;
		_pstack = nullptr;
	}
	void push(int val)
	{
		if (full())
			resize();
		_pstack[++_top] = val;
		
	}
	void pop()
	{
		if (empty())
			return;
		--_top;
	}
	int top()
	{
		return _pstack[_top];
	}
	bool empty() {
		return _top == -1;
	}
	bool full()
	{
		return _top == _size - 1;
	}
private:
	int* _pstack;//动态开票数组，存储顺序栈的元素
	int _top;//指像栈顶元素的位置
	int _size;//数据扩容的总大小
	void resize()
	{
		int* ptmp = new int[_size * 2];
		for (int i = 0;i < _size;++i)
		{
			ptmp[i] = _pstack[i];
		}
		delete[] _pstack;
		_pstack = ptmp;
		_size *= 2;
	
	}
};

SeqStack gStack; //全局变量
int main()
{
	
    /*---------------------------------栈上构造析构示例-----------------------*/
	//SeqStack s;//没有提供任何构造函数时，编译器会为你生成默认构造函数和默认析构函数（默认构造和默认析构函数是空函数）
	SeqStack s(20);	
	for (int i = 0;i < 15;++i)
	{
		s.push(rand() % 100);
	}
	while (!s.empty())
	{
		std::cout << s.top() << " ";
		s.pop();
	}
	std::cout<<std::endl;
	/*---------------------------------堆上构造析构示例-----------------------*/
	SeqStack* ps = new SeqStack(20);//相当于malloc开辟内存+然后SeqStack(20)
	ps->push(100);
	ps->push(200);
	ps->push(300);
	ps->pop();
	std::cout << ps->top() << std::endl;
	delete ps;//堆上对象构造，一定要调用delete 否则析构函数不会执行。相当于先调用~SeqStack然后free(ps)

	
}