函数重载（1）构造函数和析构函数以及相关内容

函数重载续（1）

1. 构造函数和析构函数
·构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用。
·析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。
1.1构造函数
构造函数语法：类名（）{}
1.构造函数，没有返回值也不写void
2.函数名称与类名相同
3.构造函数可以有参数，因此可以发生重载
4.程序在调用对象时候会自动调用构造，无须手动调用，而且只会调用一次

1.2析构函数
析构函数语法：~类名（）{}
1.析构函数，没有返回值也不写void
2.函数名称与类名相同，在名称前加上符号~
3.析构函数不可以有参数，因此不可以发生重载
4.程序在对象销毁前会自动调用析构，无需手动调用，而且只会调用一次

构造函数和析构函数都在类内，都必须要有的，如果我们没有加上，编译器会自动创建构造一个空实现的构造和析构。

class Person
{
public:
	Person()
	{
	cout<<"Person 构造函数的调用"<<endl;
	}	
	~Person()
	{
	cout<<"Person 析构函数的调用"<<endl;
	}	
	
};
void test01()
{
Person p; //在栈上的数据，test01执行完毕后，释放对象前会自动调用析构函数
}
int main()
{
test01();
system("pause");
return 0 ;
}

2.构造函数的分类调用
·两种分类方式：
按参数分为：有参构造和无参构造
按类型分为：普通构造和拷贝构造
·三种调用方式：
1）括号法
2）显示法
3）隐式转换法

//1.构造函数 初始化操作
class Person
{
public:
	//构造函数
	Person()  //无参/默认构造
	{
		cout << "Person的无参构造函数的调用1" << endl;
	}
	Person(int a)  //有参构造
	{
		age = a;
		cout << "Person的有参构造函数的调用2" << endl;
	}

	//拷贝构造函数 不改变要用const  而且要用引用的写法&传进来
	//·使用一个已创建完毕的对象来初始化一个对象
	//·值传递的方式给函数参数传值
	//·以值的方式返回局部对象
	Person(const Person &p)
	{
	//将传入被拷贝对象所有属性
		age = p.age;

		cout << "Person的拷贝构造函数的调用3" << endl;
	}


	~Person()  //无参/默认构造
	{
		cout << "Person的析构函数的调用4" << endl;
	}
	int age;

};
同时析构函数作用是进行清理操作


有参构造函数的调用
void test01()
{
	//1.括号法
	Person p1;//默认构造函数的调用
	Person p2(10);//有参构造函数的调用
	Person p3(p2);
	//注意事项1
	//调用默认构造函数时候不要加（）；因为下面这行代码，编译器会认为是一个函数的声明，不会是认为在创建对象
	//不能用括号法初始化无参的构造函数
	/*Person p1();*/

	cout << "P 2 的年龄为：" << p2.age << endl;
	cout << "P 3 的年龄为：" << p3.age << endl;
	

	///2显示法
	Person p1;
	Person p2 = Person(10);//有参构造
	Person p3 = Person(p2);//拷贝构造
	//注意一  Person(10)在右侧      
	//Person(10); //匿名对象 特点：在执行当前行结束后，系统会立即回收掉匿名对象

	//注意事项二
	//不要利用拷贝构造函数 初始化匿名对象   就是在匿名对象中创建拷贝对象  会从定义
	Person(p3);


	//3隐式转换法
	Person p4 = 10;    //相当于 写了 Person p4 = Person（10）
	Person p5 = p4;		//拷贝构造

}

3.拷贝析构函数的调用时机
C++中拷贝函数调用时机通常分为三种情况：
·使用一个已经创建完毕的对象来初始化一个新对象。
·值传递方式给函数参数传值。
·以值方式给函数参数传值。（值拷贝）

//1拷贝构造函数的调用时机


class Person
{

public:
	Person()
	{
	cout << "Person默认构造函数的调用" << endl;

	}
	~Person()
	{
		cout << "Person析构函数的调用" << endl;
	}
	Person(int age)
	{
		m_Age = age;

	}
	Person(const Person & p)
	{
		cout << "Person拷贝构造函数的调用" << endl;
		m_Age = p.m_Age;
	}



	int m_Age;
};


void test01()
{
	Person p1(20);
	Person p2(p1);
	cout << "P 2 的年龄为：" << p2.m_Age << endl;
}


//2.值传递的方式给函数参数传值  //值传递的本质拷贝一个临时的副本  Person p = p;
void doWork(Person p)//传到2）形参
{

}
void test02()
{
	Person p; //调用的是默认构造函数
	doWork(p); //1）实参   1）和 2）的 p不是同一个p
}
//3.值方式返回局部对象

Person doWork2()  //局部对象特点 函数执行后就会被释放 doWork执行完过后会被析构函数析构掉
{
	Person p1;
	return p1;  //返回的不是p1本身 ，用的是值的方式来返回  根据p1创建一个新的对象 然后再返回给test03
}

void test03()
{
	Person p= doWork2(); //此时外侧接受的p 是拷贝构造函数调过来的值 和doWork2创建的p1不是同一个对象
	
}
//把构造函数 和析构函数 理解为入栈 和 出栈 就可以

4.深拷贝与浅拷贝
·浅拷贝：简单的赋值拷贝操作。
·深拷贝：在堆区重新申请空间，进行拷贝操作。

4.1浅拷贝

class Person
{
public:
	//Person()
	//{
	//	cout << "无参数构造函数" << endl;
	//}
	//Person(int age, int height)
	//{
	//	cout << "有参数构造函数" << endl;
	//	m_age = age;
	
	//}int m_Age;
		Person()
		{
			cout << "Person无参构造函数调用" << endl;
		}
		Person(int age,int height)
		{
			m_Age = age;
			m_Height = new int(height);//  new 开辟一个堆区     new创建返回的是一个地址（这个地址返回的是Heighht的值）  用指针去接收一个堆区的数据（所以要用指针地址接收） 
			cout << "Person有参构造函数调用" << endl;
		}	
	
		~Person()//析构代码，将堆区开辟数据做释放操作
		{	
			if (m_Height != NULL)
			{
				delete m_Height;
				m_Height = NULL;
			}
			cout << "Person的析构构造函数调用" << endl;

		}
	
		int m_Age;
		int * m_Height;
};

void test01()
{
	Person p1(18,160);
	cout << "P 1 的年龄为：" << p1.m_Age <<"身高为："<<* p1.m_Height<< endl;//直接p1.m_Height的话是输出指针的地址  解引用过后才是表达值

	Person p2(p1);//括号法创建对象（调用拷贝构造函数创建）我们没有写拷贝构造函数但是编译器自己创了一个拷贝构造函数进行了浅拷贝操作（把age做了传递输出）
	cout << "P 2 的年龄为：" << p2.m_Age << "身高为：" <<* p1.m_Height << endl;

}
//可能出现中断的异常问题：浅拷贝下     Person p2(p1)        p1在进行有参初始化时，在堆区申请了一个空间，p1的height指针就指向这个空间；p2再进行拷贝初始化时使用的是编译器提供的浅拷贝；外部函数调用后，p1和p2把同一个空间释放了两次
//自己实现拷贝构造函数 

4.2深拷贝

//自己实现拷贝构造函数   解决浅拷贝带来的问题
Person (const Person &p)
{
     cout<<"Person拷贝构造函数调用"<<end;
     m_Age = p.m_Age;
     //m_height = p.m_Height;编译器默认实现就是这行代码。	
     //深拷贝操作
     m_Height = new int(*p.m_Height);//需要解引用的原因：new是给数据开辟地址，所以要将p.m_Height 这个地址解引用为数据，让new开辟这个数据的地址，好让指针m_Height所指
     		
}

如果属性有在堆区开辟的，自己需要提供拷贝构造函数，开辟新的地址来存储数据，防止浅拷贝带来的问题。