10构造函数与析构函数

构造函数和析构函数

#include<iostream>
using namespace std;

class seqStack {
private:
	int* _pstack;
	int _size;
	int _top;

public:
	seqStack(int size) {
		_size = size;
		_pstack = new int[size];
		_top = -1;
	}
	~seqStack() {
		delete[]_pstack;
		_pstack = nullptr;
	}
	int full() {
		return _top == _size - 1;
	}
	void resize() {
		int* newstack = new int[2 * _size];
		for (int i = 0; i < _size; i++) {
			newstack[i] = _pstack[i];
			//这里要慎用memcpy和realloc，参考深拷贝与浅拷贝
		}
		_pstack = newstack;
		_size *= 2;
	}
	int empty() {
		return _top == -1;
	}
	void push(int val) {
		if (full()) {
			resize();
		}
		_pstack[++_top] = val;
	}
	void pop() {
		if (empty()) {
			return;
		}
		cout << _pstack[_top--] << endl;
	}
};

int main() {
	seqStack st(4);
	for (int i = 0; i < 10; i++) {
		st.push(rand() % 100);
	}
	cout << sizeof(st) <<endl;
	while (!st.empty()) {
		st.pop();
	}
    //st是栈上的对象。离开作用域(本函数)，析构自动调用。
	return 0;
}

• 构造函数可以带参，可以重载。
• 析构函数不带参数，只能有一个。
• 构造和析构类似入栈和出栈，先构造后析构，后构造先析构。
• 堆上的类对象，不会在程序结束后自动释放，需要手动释放。因此一定要手动调用析构函数

int main() {
	seqStack* st = new seqStack(4);
	for (int i = 0; i < 10; i++) {
		st->push(rand() % 100);
	}
	cout << sizeof(st) <<endl;
	while (!st->empty()) {
		st->op();
	}
    delete st;
    //st是栈上的指针对象，但它指向的堆上的对象会一直占据空间。
	return 0;
}

• 栈上初始化一个类对象，两步：开内存，调用构造函数。
• 堆上new一个类对象，两步：malloc申请一段空间，调用构造函数。
• free和delete都用来释放堆上申请的空间，它们在释放类对象的区别是什么？delete释放类对象是两步：
  • 调用此类的析构函数。
  • free类对象的指针。