文章目录

• 一. 构造函数
• 二. 析构函数
• 三. 拷贝构造函数
• • 1.浅拷贝
  • 2.深拷贝
• 四. 赋值函数

在C++中，对于一个类，C++的编译器都会为这个类提供四个默认函数，分别是：

A() //默认构造函数
~A() //默认析构函数
A（const A&) //默认拷贝构造函数
A& operator = (const A &) //默认赋值函数。

这四个函数如果我们不自行定义，将由编译器自动生成这四个缺省的函数，下面让我们来看看这四个函数（重点是后两个）。

一. 构造函数

构造函数是一种特殊的成员函数，与其他成员函数不同，不需要用户来调用它，而是在建立对象时自动执行。构造函数的功能是由用户定义的，用户根据初始化的要求设计函数体和函数参数，可以是一个，也可以是多个，可以把构造函数理解为重载的一种（函数名相同，不会返回任何类型，也不可以是void类型，参数类型个数可不同）。

class Animal
{
private:
	string name;
public:
	Animal();//默认构造函数
	Animal(string n);//也可以自定义构造函数
};

Animal::Animal()
{
	//什么都不做
}
Animal::Animal(string n)
{
	this->name = n;
}

int main()
{
	//第一种实例化对象的方法
	Animal * a = new Animal(); //将调用默认构造函数
	Animal * b = new Animal("花狗"); //将调用自定义的构造函数，对name变量初始化。
	
	//第二种实例化对象的方法
	Animal c; //将调用默认构造函数 
	//注意：对于无参构造函数，不可以使用Animal c(),
	Animal c("花狗");//将调用自定义构造函数，对name变量初始化。
	return 0;
}

构造函数的作用就是对当前类对象起到一个初始化的作用，类对象不像我们基本类型那样，在很多时候都需要初始化一些成员变量。

可以看到构造函数被声明在public里面，那么可以声明在private里面吗？是可以的，只不过不能被外部实例化了，在设计模式中有一种单例模式，就是这样设计的，有兴趣的可以了解一下。

二. 析构函数

与构造函数相对立的是析构函数，这个函数在对象销毁之前自动调用，例如在构造函数中，我们为成员变量申请了内存，我们就可以在析构函数中将申请的内存释放，析构函数的写法是在构造函数的基础上加一个~符号，并且只能有一个析构函数。

class Animal
{
private:
	string name;
public:
	Animal();//默认构造函数
	~Animal(); //默认析构函数
};

三. 拷贝构造函数

1.浅拷贝

class Animal
{
private:
	string name;
public:
	Animal()
	{
		name = "花狗";
		cout << "Animal" << endl;
	}
	~Animal()
	{
		cout << "~Animal:" << (int)&name << endl;
	}
};

int main()
{
	Animal a;
	Animal b(a);
	return 0;
}

运行结果：

2.深拷贝

我们将成员变量换成指针变量，继续实验。

class Animal
{
private:
	//string name;
	string * name;
public:
	Animal()
	{
		name = new string("花狗");
		cout << "Animal" << endl;
	}
	~Animal()
	{
		cout << "~Animal:" << (int)name << endl;
	}
};

int main()
{
	Animal a;
	Animal b(a);
	return 0;
}

运行结果：

可以看到两个对象的指针成员所指的内存相同（内存里面存着字符串：花狗），还记得析构函数的作用吗，在对象销毁之前自动调用，在构造函数中，我们为成员变量申请了内存，我们就可以在析构函数中将申请的内存释放。

现在在析构函数中加上对name释放的代码：

	~Animal()
	{
		cout << "~Animal:" << (int)name << endl;
		delete name;
		name = NULL;
	}

再运行发现程序崩溃了，调用一次构造函数，调用两次析构函数，两个对象的指针成员所指内存相同，name指针被分配一次内存，但是程序结束时该内存却被释放了两次，导致程序崩溃

例如下面的代码将不会发生奔溃

	string * a = new string("花狗");
	delete a;
	a = NULL;
	cout << "第一次完成n";
	delete a;
	a = NULL;
	cout << "第二次完成n";

现在我们已经知道对于指针进行浅拷贝会出现的奔溃的问题，那么通过自定义拷贝构造函数来解决浅拷贝的问题。

	Animal(const Animal & a)
	{
		//name = s.name;
		name = new string(*a.name);
	}

之后运行程序不会崩溃，总结起来就是先开辟出和源对象一样大的内存区域，然后将需要拷贝的数据复制到目标拷贝对象。

四. 赋值函数

四个默认函数，当赋值函数最为复杂。

Animal& operator=(const Animal&obj)
	{
		if(this !=&obj)
		{
			data=obj.data;
		 } 
		 return *this;
	}

这是它的原型，类似 Animal a(b); Animal a = b; 这样的写法会调用拷贝构造函数。

而赋值函数是在当年对象已经创建之后，对该对象进行赋值的时候调用的，Animal a; a = b。

和拷贝构造函数一样，若类中有指针变量，自动生成的赋值函数注定会出错，老样子，先申请内存，再复制值即可完美解决。

Animal& operator=(const Animal&obj)
	{
		if(this !=&obj)
		{
			//默认是 name = obj.name;
			name = new string(*obj.name);
		 } 
		 return *this;
	}

还有一个知识点就是运算符重载这一块，一个自定义类型的对象，如果想要进行预期的加减乘除之类的运算，或者是像内置类型一样，用cout输出一个类对象，这些都是需要我们来用代码告诉机器怎么做，都是需要我们来指定的。

还是拿这个类举例子，例如运算符+重载

class Animal
{
private:
	string * name;
	int age;
	int num;
public:	
Animal()
{
	name = new string("花狗");
	age = 5;
	num = 4;
}


Animal& operator+(const Animal&obj)
	{
		if(this !=&obj)
		{
			string * s = name;
			name = new string(*name + *obj.name);
			delete s;
			s == NULL;
			this->age+=obj.age;
			this->num+=obj.num;
		} 
		 return *this;
	}
};

int main()
{
	Animal a;
	Animal b;
	a = a+b;
	//这样对象a里面的age成员的值是5，num成员的值是8，而*name的值将是"花狗花狗";
	return 0;
{

cout输出的定义，主要注意的是要用到友元函数。

class Animal
{
	//中间代码略
	friend ostream& operator << (ostream& os, Animal& a)
	{
		os << *a.name << ":" << a.age << ":" << a.num;
		return os;
	}
};

运行结果：

微信官方交流群：

（编辑：北几岛）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!