析构函数与运行错误

  今天在做数据结构的实验课作业时，突然一直运行错误，可我检查了几次代码，也没有发现哪里有错（也并没有经常导致运行错误的，数组越界那些），经过20min左右的试探和摸索，终于发现了这次运行错误的时间，并且，还和析构函数有些关系

 

 (而且，最尴尬的是，在我发现以后，我才想起来，这个错误在我学C++的时候就犯过了，当时我还在自己的代码上注释过这个错误，强调以后要注意)…

 

然而到学数据结构时，居然印象已经不太深刻了…故写此博文，一方面，以后自己再犯这个错，可以快速找到；另一方面，如果有人不幸踩到这个坑，也许他们能从这篇中有一二启发。

 

  题目：

我最初的代码（DevC上正常运行，但在oj上报错）：

#include <iostream>
#include <cstring>
using namespace std;
const int ok = 0;
const int error = -1;
const int maxn = 1e3 + 5;
int data[maxn];

class SeqList
{
private:
	int *list;
	int maxsize;
	int size;
public:
	SeqList()
	{
		maxsize = 1000;
		size = 0;
		list = new int[maxsize];
	}
	void init(int n)
	{
		size = n;
		for (int i = 0; i < n; i++) cin >> list[i];
	}
	~SeqList()
	{
		delete[]list;
	}
	void list_display()
	{
		cout << size << " ";
		for (int i = 0; i < size; i++) cout << list[i] << " ";
		cout << endl;
	}
	friend void MergeList(SeqList a, SeqList b, SeqList &c);
};

void MergeList(SeqList a, SeqList b, SeqList &c)
{
	int s_a = a.size, s_b = b.size, i, j, k;
	c.size = s_a + s_b;
	
	for (i = 0, j = 0, k = 0; i < s_a && j < s_b; )
	{
		if (a.list[i] < b.list[j]) c.list[k++] = a.list[i++];
		else c.list[k++] = b.list[j++];
	}
	
	while (i < s_a) c.list[k++] = a.list[i++];
	while (j < s_b) c.list[k++] = b.list[j++];
}

int main()
{
	SeqList temp1, temp2, ans;
	int size;
	cin >> size;
	temp1.init(size);
	cin >> size;
	temp2.init(size);

	MergeList(temp1, temp2, ans);
	ans.list_display();
	
	return 0;
}

报错信息：

/*
Runtime Error:[ERROR] A Not allowed system call: runid:143894 callid:146

*** glibc detected *** ./Main: double free or corruption (!prev): 0x084c1650 ***
Runtime Error:[ERROR] A Not allowed system call: runid:143894 callid:146

*** glibc detected *** ./Main: double free or corruption (!prev): 0x08b64650 ***
辅助解释：
A Not allowed system call: runid:143894 :使用了系统禁止的操作系统调用，看看是否越权访问了文件或进程等资源

*/

报错页面截图：

  百思不得其解，我就开始搜这些错误提示，然而搜了十几分钟，也一无所获，他们提到的数组越界等问题，我也没有，而对于ans列表，我也有给它的list数组动态分配足够大的空间。我仔仔细细检查了几次，还是觉得自己找不到错（此处对我当时的无知进行了美化，其实我当时是觉得，我应该没错吧，好像是oj错了）

  就在这时，突然想到了上学期学C++的类时，经常容易在析构函数上犯错，于是屏蔽了析构函数，提交一次

  发现屏蔽析构函数以后，居然就没有运行错了，可谓是又惊又喜....

  接下来我仔细想了想，这两种到底有什么区别，为什么没有析构就能通过，这时我突然想起

  因为我在 MergeList中，传入的参数 a 和 b 都是按照值传递的方式传递的，既然为值传递，作为临时变量，传参时会自动调用构造函数，返回时，会自动调用参数的析构函数...(而析构函数，本来是不会清楚动态分配的空间的，但既然我重写了析构，那new出来的数组空间，肯定都被析构掉了)

  可是，有一个很严重的问题是，a 和 b 作为参数传入时，它们的list数组，和主函数中的 temp1 和 temp2 的list数组，是共享空间的。而主函数与逆行完以后，temp1 和 temp2 必定也会调用析构函数，就相当于把同一个空间，析构了两次，自然会有运行错误

  那么，有没有什么方法能避免这个错误呢？

  

  当然是有的~

  1.  首先，如果不写析构函数就行，就如我的上一张截图，不自己写，默认的析构函数，是不会析构动态分配的空间的，虽然这种做法，毕竟还是不合适，但它确实可以避免许多问题

  （BTW，在这里说一下，重写析构函数以后，真的需要万事小心，我现在突然想起来，当初学C++的类时，几乎所有的错误，都是出现在析构函数上的，每次一屏蔽它就没事，不然就一直有错误）

  2.  更加推荐的处理方法时，将 a 和 b 用引用的方式传递为参数，这样a和b就不是临时对象，函数也就不会在返回时，自动调用它们的析构函数了，就像这样

  const只是避免自己不小心改了不该改的a和b，不加也行，关键是一定要加上引用

  而且这个方法还有一个除了避免出错之外的好处，就是...运行速度更快了，从8变成了0

  从这个故事中，得到了一个教训：

  经常踩的坑，也还是应该好好记录整理下来。想当初，踩了那么多次析构函数的坑，出了那么多次运行错误，我以为印象深刻到，随时都能想起来的地步了。然而，今天还是找了很久才发现

  因此，特开博客的“经验教训”分类，以记下我在编程上遇到的，比较特别，或者比较值得记录下来的错误，并记下自己当时是怎么解决的。