从C到Cpp——十四、类的默认函数以及它们的隐患

一、类的默认函数

类的默认函数包括以下这些：

1. 默认构造函数
2. 默认析构函数
3. 复制构造函数
4. 默认重载的赋值运算符
5. 默认重载的地址运算符

和默认构造函数一样，如果程序员在设计类时不主动提供这些函数的定义，那么编译器会自动生成这些函数的定义。而如果程序员主动提供这些函数的定义，那么这些函数的默认定义会被覆盖。

二、默认构造函数

我们已经详细讨论过默认构造函数了，这里不予重复讨论。只有一点需要特别说明，如果要在类中定义一个符合类型，那么需要在构造函数中为其分配空间。

#include <iostream>
#include <cstring>
class Mystring
{
	private:
		char* context;
		int len;
	public:
		Mystring(const char* str); 
};

Mystring::Mystring(const char* str)
{
	len=strlen(str);
	context=new char[len+1];
	strcpy(context,str);
}

三、默认析构函数和潜在的内存泄露

默认析构函数会释放类成员对象，但不会释放为类成员对象分配的空间。这就意味着如果类成员是已经分配空间的指针，那么简单地使用默认析构函数会导致这部分内存的不释放。这就意味着内存泄漏！

所以，如果已经给类成员对象分配空间了，必须自己设计一个析构函数来释放空间。举例而言，上面这个Mystring类显然就需要一个析构函数。

Mystring::~Mystring()
{
	delete [] context;
}

上面的问题想必读者都能意识且规避到，但在实践中下面的问题往往非常隐蔽

四、复制构造函数以及潜在的非法访问和内存丢失

1--什么是复制构造函数？

复制构造函数用于将一个已有的对象复制到新创建的对象中，也就是说，它被用于初始化的过程中，而不是常规的赋值过程中。

具体而言，假设Student是一个简单的类

class Student
{
    int age;
    int grade;
};

而student1是一个已经被创建的对象

int main(void)
{
    Student student1;
}

那么在接下来的代码中，以下五种情况可能会引发复制构造函数的隐式使用！

Student student2(student1);

Student student3=student1; 

Student student4=Student(student1);

Student *pstudent=new Student(student1)

void func(Student studentx)
{
    ......
}
......
func(student1);

对于第一种，很好理解，编译器检测到了程序员用了一个现有对象来初始化一个新建对象，它等价于调用下面一个函数。

Student(const Student& st)
{
	age=st.age;
	grade=st.grade;
}

（有趣的是，自定义复制构造函数会覆盖默认构造函数，如果定义了复制构造函数，请自定义构造函数！）

对于第二种和第三种，编译器可能调用直接调用复制构造函数，也可能是先利用复制构造函数创建一个名称隐藏的临时对象，然后利用利用默认重载的赋值运算符把值赋予目标对象！(这个稍后会解释)

对于第四种，编译器会首先利用复制构造函数创建一个匿名对象，然后再把这个对象的地址赋给目标指针！

对于第五种，需要特别注意。由于函数传参是按照值传递的，编译器会先利用复制构造函数创建一个作用域和持续时间仅在这个自定义函数种的临时对象，然后再利用析构函数清除这个临时变量。

2--如何自定义复制构造函数

复制构造函数的原型是

Class_name(const Class_num &);

举例而言：

Student(const Student &studentx);

就Student这个类而言，它的默认形式如下：

Student(Student const& studentx)
{
    age=studentx.age;
    grade=studentx.grade;
}

编码者可以自己定义这个函数，但需要注意。自定义的复制构造函数会覆盖默认构造函数。如果自定义了复制构造函数，必须自定义需要构造函数。

3--复制构造函数与潜在的非法访问

对于Student这个类来说，默认的复制构造函数不会引发问题。但是，涉及了动态内存分配的类，这样操作会引发非法的内存访问。以开始我们设计的Mystring类为例，它默认的复制构造函数为：

Mystring(const Mystring& str)
{
    str=str.context;
}

这意味着，新创建的Student类类对象中的成员context指针没有被分配空间。它只是和被复制的对象共享相同的空间。而这对于封闭的对象来说是不允许的！

4--复制构造函数是与潜在的内存丢失

函数传参时调用默认的复制构造函数，会引发更严重的问题。函数中创建的临时对象和被复制的对象共享相同的空间。而临时对象是通过析构函数释放的，析构函数又包含delete[]的代码。这意味着删除临时对象的过程会导致被复制对象，也就是传入的参数中的数组空间被提前释放！

#include <iostream>
#include <cstring>
class Mystring
{
	private:
		char* context;
		int len;
	public:
		Mystring(const char* str); 
		Mystring();
		~Mystring();
		friend std::ostream& operator<<(std::ostream& os,const Mystring &str)
		{
			os<<str.context;
			return os;
		}
};

Mystring::Mystring(const char* str)
{
	len=strlen(str);
	context=new char[len+1];
	strcpy(context,str);
}

Mystring::Mystring()
{
	
}

Mystring::~Mystring()
{
	delete [] context;
}

void func(const Mystring str)
{
	std::cout<<str<<std::endl;
}

int main(void)
{
	Mystring s1("hello");
	std::cout<<s1<<std::endl;
	func(s1);
	std::cout<<s1;
	return 0;
}

输出结果是：

hello

hello

p/

之所以出现这个问题，就是因为因为自定义函数结束临时变量的释放会导致s1内存的丢失！

要修正这个问题，可以自己定义复制构造函数，也可以把自定义函数改为按照引用传参的版本！

void func(const Mystring &str)
{
	std::cout<<str<<std::endl;
}

或者添加：

Mystring::Mystring(const Mystring &str)
{
	len=str.len;
	context=new char[len+1];
	strcpy(context,str.context);
}

五、默认的运算符函数

赋值运算符的重载也是默认的。其默认形式如下：

Class_num& Class_num::operator=(const Class_num&);

具体例子如下：

Mystring& Mystring::operator=(const Mystring& str);

和复制构造函数一样，该函数会把值完完全全复制给目标对象。这就意味着如果包含已经分配空间的指针成员，也要重新设计运算符函数！