C++：简单理解 在模拟STL容器时内存泄漏问题

前言

学习了类和对象，那么要通过类和对象模拟STL的容器，有哪些注意点？

示例代码

编写了一个类来模拟容器：

class SeqList
{
private:
	int* data;		//指向的堆空间
	int maxsize;	//总空间大小
	int cursize;	//当前对象个数
	
public:
	SeqList() : data(NULL), maxsize(SEQ_INIT_SIZE), cursize(0)
	{
		data = (int*)malloc(sizeof(int) * maxsize);
	}
	~SeqList()
	{
		free(data);
		data = NULL;
	}

	SeqList(const SeqList& seq)
	{
		data = seq.data;
		maxsize = seq.maxsize;
		cursize = seq.cursize;
	}

	SeqList& operator =(const SeqList& seq)
	{
		if (this != &seq)
		{
			data = seq.data;
			maxsize = seq.maxsize;
			cursize = seq.cursize;
		}
		return *this;
	}
};

内存模型简图：

在没有自己编写类的拷贝构造和等号运算符重载函数时，系统的缺省函数就是示例代码这样所写的。

问题1：重复析构

那么如果这样构造对象时，即使用拷贝构造，出现的问题是：

int main(void)
{
	SeqList seqa;
	SeqList seqb(seqa);

	return 0;
}

在拷贝构造后，两个对象的data域指向同一块内存：

所以出现的问题就是，在析构对象的时候，会导致重复析构，引发崩溃：

问题2：内存泄漏

如果是这样构造的对象：

int main(void)
{
	SeqList seqa;
	SeqList seqb;
	seqb = seqa;
	return 0;
}

在把 seqa赋值给 seqb 后，情况会变成这样：

在赋值后，两个对象的data指向同一空间

除了引发重复析构之外，最初始的seqb对象所开辟的空间没办法析构，还会引发内存泄漏。

总结

我们在设计类的时候，

1. 如果要设计指针，或者要设计指向内核态的对象时，要重写拷贝构造和等号运算符重载。
2. 如果类内有打开文件的操作，即获取外部资源，那么也要重写。
3. 如果类内设计了互斥量、信号量等，也要重写。

改进拷贝构造（深拷贝）

	SeqList(const SeqList& seq)
	{
		maxsize = seq.maxsize;
		cursize = seq.cursize;
		data = (int*)malloc(sizeof(int) * seq.maxsize);
		memcpy(data, seq.data, sizeof(int) * seq.cursize);
	}

这样拷贝构造时，内存模型为：

这样在程序结束时，就不会出现重复析构的错误。

改进等号运算符重载

	SeqList& operator =(const SeqList& seq)
	{
		if (this != &seq)
		{
			free(data);
			data = (int*)malloc(sizeof(int) * seq.maxsize);
			memcpy(data, seq.data, sizeof(int) * seq.cursize);
			maxsize = seq.maxsize;
			cursize = seq.cursize;
		}
		return *this;
	}

这样做避免了内存泄漏。