C++ 一些学习笔记（七）类和对象-对象的初始化和清理

主要是针对之前学习C的时候一些知识点的遗漏的补充，还有一些我自己觉得比较重要的地方。

本文章的主要内容是关于对象的初始化和清理的。

C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置

1.构造函数与析构函数

对象的初始化和清理也是两个非常重要的安全问题。一个对象或者变量没有初始状态，对其使用后果是未知的；同样的使用完一个对象或者变量，没有及时清理，也会造成一定的安全问题。

C++利用构造函数和析构函数解决上述问题，这两个函数会被编译器自动调用，完成对象初始化和清理工作。对象的初始化和清理是工作是编译器强制要求我们的，因此如果我们不提供构造和析构，编译器会提供。
但是，编译器提供的构造函数和析构函数是空实现。

1. 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用无需手动调用
2. 析构函数：主要作用在于对象销毁前的系统自动调用，执行一些清理工作

构造函数语法：类名(){}
1.构造函数没有返回值，也不写void
2.函数名称与类名相同
3.构造函数可以有参数，因此可以发生重载
4.程序在调用对象时会自动调用构造，无需手动调用，而且只会调用一次

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

对象的初始化和清理
//1.构造函数 进行初始户操作
class Person{
public:
//1.1构造函数
	//没有返回值 不用写void
	//函数名 与类名相投
	//构造函数可以有参数，可以发生重载
	//程序在调用对象时会自动调用构造，无需手动调用，而且只会调用一次
	Person()
	{
		cout<<"Person 构造函数的调用"<<endl;
	}
//1.2析构函数
	//没有返回值，不写void
	//函数名和类名相同 在名称前加~
	//析构函数不可以有参数，不可以发生重载
	//程序在对象销毁前会自动调用析构，无需手动调用，而且只会调用一次
	~Person()
	{
		cout<<"Person的析构函数嗲用"<<endl;
	}
}

//构造和析构都是必须有的事项，如果我们不提供，编译器会提供一个空实现的构造和析构
void test01(){
	Person P;//在栈上的数据，test01在执行完成后，会释放这个对象
}
int main(){
	test01();
	Person P;//直接写在main函数中执行只有构造，没有析构
}

1.构造函数的分类及调用

两种分类方式

• 按参数分为：有参构造、无参构造
• 按类型分为：普通构造、拷贝构造

三种调用方式：括号法、显示法、隐式转换法

1.构造函数的分类及调用
//分类
//按照参数分类：有参构造、无参构造（默认构造）
class Person{
public:
	//构造函数
	Person()
	{
		cout<<"Person的无参构造函数调用"<<endl;
	}
	Person(int a)
	{
		age=a;
		cout<<"Person的有参构造函数调用"<<endl;
	}
	//拷贝构造函数
	Person （const Person &P){
	//将传入的人身上所有属性拷贝到我身上
	cout<<"Person的拷贝构造函数调用"<<endl；
	age=p.age;
	}
	~Person()
	{
		cout<<"Person的析构函数调用"<<endl;
	{
	int age;
}；
void test01(){
	//括号法
	Person p1;//默认构造函数的调用，注意：调用默认构造函数时，不要加()，Person p1();//编译器会认为这是一个函数声明，不会认为在创建对象
	Person p2(10);//有参构造函数的调用
	Person p3(p2);//拷贝构造函数的调用
	
注意事项：调用默认构造函数时，不要加()
	//cout<<"p2的年龄为："<<p2.age<<endl;
	//cout<<"p3的年龄为："<<p3.age<<endl;
	
	//显示法
	Person p1;
	Person p2=Person(10);//有参构造
	Person p3=Person(p2);//拷贝构造
注意事项：//Person(10);//匿名对象  特点：当前行执行结束后，系统会立即回收掉匿名对象
		//Person(p3);//不要利用拷贝构造函数 初始化匿名对象,编译器会认为Person(p3)=Person p3;
	//隐式转换法
	Person p4=10;//相当于 Person p4=Person(10);有参构造
	Person p4=p5;//拷贝构造
}

3.拷贝构造函数的调用时机

C++中拷贝构造函数调用时机通常有三种情况

• 使用一个已经创建完毕的对象来初始化一个新对象
• 值传递的方式给函数参数传值
• 以值方式返回局部对象

拷贝函数调用时机
//1.使用一个已经创建完毕的对象来初始化一个新对象
//2.值传递方式给函数参数传值
//3.值方式返回局部对象
class Person{
public:
	Person(){
		cout<<"Person默认构造函数调用"<<endl;
	}
	Person(int age){
		cout<<"Person有参构造函数调用"<<endl;
		m_Age=age;
		}
	Person(const Person &p){
		cout<<"Person有参构造函数调用"<<endl;
		m_Age=p.m_Age;
	}
	~Person(){
		cout<<"Person析构函数调用"<<endl;
	}
}；
void test01(){//1.使用一个已经创建完的对象来初始化一个新对象
	Person p1(20);
	Person p2(p1);
	cout<<"P2的年龄为："<<p2.m_Age<<endl;
}
void doWork(Person p){//2.值传递的方式给函数参数传值
	
}
void test02(){
	Person p;
	doWork{p);
}
void doWork2(){//值方式返回局部对象
	Person p1;
	cout<<(int*)&p1<<endl;
	return p1;
}
void test03(){
	Person p=doWork2();
	cout<<(int*)&p<<endl;
}
int main(){
	test01();
	test02();
	test03();
}

3.构造函数调用规则

默认情况下，C++编译器至少给一个类添加三个函数：
1.默认构造函数（无参，函数体为空）
2.默认析构函数（无参，函数体为空）
3.默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

• 如果用户定义有参构造函数，C++就不再提供无参构造，但是会提供默认拷贝构造
• 如果用户动议拷贝构造函数，C++不再提供其他构造函数

1.构造函数的调用规则
默认情况下，C++编译器至少给一个类添加三个函数：
默认构造函数（无参，函数体为空）空实现
默认析构函数（无参，函数体为空）空实现
默认拷贝构造函数，对属性进行值拷贝

2.如果用户定义有参构造函数，C++就不再提供无参构造，但是会提供默认拷贝构造
 - 如果用户动议拷贝构造函数，C++不再提供其他构造函数
class Person{
public:
	Person(){
	cout<<"Person的默认构造函数调用"<<endl;
	}
	Person(int age){
		m_Age=age;
		cout<<"Person的有参构造函数调用"<<endl;
	}
	Person(const Person &p){
		m_Age=p.Age;
		cout<<"Person的拷贝构造函数调用"<<endl;
	}
	~Person(){
	cout<<"Person的默认构造函数调用"<<endl;
	}
}；
void test01(){
	Person p;
	p.m_Age=18;
	Person p2(p);
	cout<<"p2的年龄为："<<endl;
}
void test02(){
	Person p(18);
	Person p2(p);
}
int main(){
	test01();
	test02();
}

4.深拷贝与浅拷贝

深拷贝与浅拷贝是经典面试问题

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

class Person{
public:
	Person(){
	cout<<"Person的默认构造函数调用"<<endl;
	}
	Person(int age,int height){
		m_Age=age;
		m_Height=new int(height);
		cout<<"Person的有参构造函数调用"<<endl;
	}


自己实现一个拷贝构造函数来解决浅拷贝带来的内存重复释放问题
	Person(const Person &p){
		cout<<"Person的拷贝构造函数调用"<<endl;
		m_Age=p.Age;
		//m_Height=p.m_Height;//编译器默认实现就是这行代码

//深拷贝操作
	m_Height=new int(*p.m_Height);//自己重新在堆区再申请一块空间
	}


析构代码，将堆区开辟的数据做释放
	~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);
	cout<<"p1的年龄为"<<p1.m_Age<<"身高为："<<*p1.m_Height<<endl;
	Person p2(p1);
	cout<<"p2的年龄为"<<p2.m_Age<<"身高为："<<*p2.m_Height<<endl;
}





总结：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

5.初始化列表

作用：C++提供了初始化列表语法
语法：构造函数()：属性1(值1),属性2(值2)...{}

class Person{
public:
	//Person(int a,int b,int c){
		// m_A=a;
		 //m_B=b;
		 //m_C=c;
	}
初始化列表，初始化属性
Person(int a,int b,int c):m_A(a),m_B(b),m_C(c);初始化列表，初始化属性
	int m_A;
	int m_B;
	int m_C;
};
void test01(){
	//Person p(10,20,30);
	Person (10,20,30);
	cout<<"m_A="<<endl;
	cout<<"m_B="<<endl;
	cout<<"m_C="<<endl;
	}
int main(){
	test01();
}

6.类对象作为类成员

C++类中成员可以作为另一个类的对象，我们称该成员为对象成员

类对象作为类成员
class Phone{//手机类
public:
	Phone(string pName){
		m_PName=pName;
	cout<<"Phone的构造函数调用"<<endl;	}
	string m_PName;
}
class Person{//人类
public:
	Person(string name,string pName):m_Name(name),m_Phone(pName)
	{
	cout<<"Person的构造函数调用"<<endl;
	}

	string m_Name;
	Phont m_Phone;
};
~Person(){
	cout<<"Person的析构函数调用"<<endl;
	}
~Phone(){
	cout<<"Phone的析构函数调用"<<endl;
	}
当其他类作为本类对象，构造时候先构造对象，再构造自身
析构时，与构造的顺序相反

void test01(){
	Person p("张三","苹果");
	cout<<p.m_Name<<"拿着"<<p.m_Phone.mPName<<endl;
	}
int main(){
	
}

7.静态成员

静态成员就是在成员变量和成员函数前加关键字static，称为静态成员
静态成员分为：

• 静态成员变量
  所有对象共享同一份数据
  在编译阶段分配内存
  类内声明、类外初始化
• 静态成员函数
  所有对象共享同一个函数
  静态成员函数只能访问静态成员变量

//静态成员变量
class Person(){
public:
	static int m_A;//所有对象都共享同一份数据、在编译阶段分配内存、类内声明，类外初始化
private：
	静态成员变量也是有访问权限的
	static int m_B;
};
int Person::m_A=100;//类外初始化
int Person::m_B=200;//类外初始化
void test01(){
	Person p;
	cout<<"p.m_A"<<endl;
	Person p2;
	p2.m_A<<endl;
	cout<<"p.m_A"<<endl;
	}
void test02(){静态成员变量不属于某个对象上，所有对象共享一份数据，因此静态成员变量有两种访问方式
1.通过对象访问
	Person p;
	cout<<p.m_A<<endl;
2.通过类名访问
	cout<<Person::m_A<<endl;
	//cout<<Person::m_B<<endl;//类外不可以访问私有静态成员变量
}
int main(){
	test01;
	test02；
}

//静态成员函数
class Person{
public:
	static void func(){//静态成员函数
	m_A=100;//静态成员函数可以访问静态成员变量
	//m_B=200;//静态成员函数不可以访问非静态成员变量，无法区分是哪个对象的m_B属性
	cout<<"static void func调用"<<endl;

静态成员函数也是有访问权限的
private:
	static void func2(){
		cout<<"static void func2的调用"<<endl;
	}
	static int m_A;//静态成员变量
	int m_B;//非静态成员变量
};
int Person::m_A=0;
void test01(){
1.通过对象访问
	Person p;
	p.func();
2.通过类名访问
	Person::func();
	Person::func2();//类外不可以访问私有静态成员函数
}
int main(){

}