#3【构造函数与析构函数】

01.普通构造函数

1. 是一个特殊的成员函数
2. 用来在创建对象时初始化对象，为对象的成员变量
3. 构造函数名要和类名一致
4. 构造函数没有返回值类型，也没有返回值（这里没有返回值跟void类型不同，因为void是一种返回值类型）
5. 构造函数可以重载，需要满足函数重载的条件（#1：同一个项目中定义的函数名字可以重复；函数名必须一致&&参数列表不同，避免二义性）
6. 如果你没有写构造函数，系统会自动给一个默认的无参数构造函数
7. 构造函数在创建一个对象时系统会自动调用，自己不能主动调用
8. 有时数据成员必须初始化
9. 不能在构造函数中赋值——用成员初始化列表的方式给初始成员赋值

补充：

1. C语言中对一个变量用const修饰后，就赋予“只读”的属性，不能直接修改（仍是变量）
2. C++中const修饰会对一个变量直接改变性质为一个常量

02.析构函数

1. 一种特殊的函数
2. 主要作用是在对象生命周期结束时做清理工作
3. 系统可以自动调用析构函数
4. 函数名与类名相同，在前面加上一个~
5. 没有返回值类型和返回值，也没有参数
6. 有低保：没写系统会给默认的析构函数
7. 析构函数可以主动通过对象调用
8. 析构函数必须是公有属性
9. 在对象生命周期结束时会自动调用析构函数
10. 不是因为调用了析构函数导致生命周期结束，是对象生命周期结束时会自动调用析构函数
11. 先构造的后析构

03.拷贝构造函数

1. 是一种特殊的构造函数
2. 通过拷贝构造函数完成一个复制的过程（从一个对象复制得到另一个对象）
3. 特殊：参数是本类的对象的引用
4. 先是构造函数，才可能是拷贝构造函数
5. 有低保：没写系统会默认给，将成员一一赋值
6. 可以自定义

#include <iostream>
using namespace std;

class MyClass
{
	MyClass(){}
	~MyClass(){}
	MyClass(const MyClass& obj){}//是拷贝构造
	MyClass(const MyClass& obj,int n,int m){}//是拷贝构造
	MyClass(int n, const MyClass& obj, int m) {}//不是拷贝构造
};

int main()
{
	
	return 0;
}

#include <iostream>
#include <string>
using namespace std;


class Monster
{
public:
	string m_name;
	int m_hp;
	float m_speed;

public:
	Monster();//构造
	Monster(const char* name,int hp,float speed);//构造
	Monster(Monster& obj);//拷贝构造
	Monster(Monster& obj, int val);//拷贝构造重载
	~Monster();//析构

	void showData();
private:

};

Monster::Monster()//无参构造
{
	cout << "无参构造" << endl;
	m_name = "名字";
	m_hp = 100;
	m_speed = 10.0f;
}

Monster::Monster(const char* name, int hp, float speed)//有参构造
{
	cout << "带参构造" << endl;
	m_name = name;
	m_hp = hp;
	m_speed = speed;

}

Monster::Monster(Monster& obj)//拷贝构造
{
	cout << "拷贝构造1" << endl;
	m_name = obj.m_name;
	m_hp = obj.m_hp;
	m_speed = obj.m_speed;
}

Monster::Monster(Monster& obj,int val)//拷贝构造重载
{
	cout << "拷贝构造2" << endl;
	m_name = obj.m_name;
	m_hp = val;
	m_speed = obj.m_speed;
}

Monster::~Monster()
{
	cout << "析构函数" << endl;
}

void Monster::showData()
{
	cout << "角色名称：" << m_name << endl;
	cout << "当前血量：" << m_hp << endl;
	cout << "移动速度：" << m_speed << endl;
	cout << "**************" << endl<< endl;
}

int main()
{
	Monster m0;//没传参数，无参构造
	Monster m1("黄金王兽", 120, 6.5f);
	Monster m2 = m0;
	Monster m3(m0);
	Monster m4(m1, 180);

	Monster* p = new Monster;

	m0.showData();
	m1.showData();
	m2.showData();
	m3.showData();
	m4.showData();
	p->showData();//需要主动释放

	delete p;
	p = NULL;

	return 0;
}

拷贝构造函数的调用时机：

• 使用一个对象给另一个对象进行初始化；如上述代码中m3(m0);m4(m1,180);
• 使用一个对象构造另一个对象m2=m0
• 函数的参数是类的对象
• 函数的返回值是类的对象 return obj; 返回的是obj的备份，此时会拷贝构造

深拷贝与浅拷贝：

• 浅拷贝：默认的都是浅拷贝，一一对应赋值，无脑抄（如果指针直接复制，会导致两个指针指向同一个内存，产生冲突）
• 深拷贝：需要自己根据实际情况选择性拷贝实现，该抄的抄，不该抄的自己修改

怎么防止默认拷贝发生？

• 声明一个私有的拷贝构造函数，但是不对它进行定义；
• 主动让程序报错