2021自学C++核心编程之对象初始化(构造函数)和清理(析构函数)以及静态成员(五)

4.2 对象的初始化和清理

生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全，同理，C++中创建每个对象也都会有初始设置以及对象使用完销毁前的清理数据的设置，以保证程序安全运行！

4.2.1 构造函数和析构函数

对象的初始化和清理也是两个非常重要的安全问题

1. 一个对象或者变量没有初始状态，对其使用后果是未知

2. 反之使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

c++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。

对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供

注意:编译器提供的构造函数和析构函数是空实现。

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

构造函数语法：

类名(){
    //空实现:指任何类中默认存在无参构造函数且函数体内不做任何操作，创建对象时，编译器自动调用提供的无参构造函数且不做任何其他操作
}

书写构造器的规则:

1. 构造函数没有返回值也不写void
2. 构造器的方法名称和类名相同（首字母一定要大写）

注意事项：

• 默认在任意一个类中，如果不存在任何构造器，那么c++会填充一个无参的构造函数，且为空实现
• 程序在类创建对象时会自动调用构造，无须手动调用,而且只会调用一次

#include<iostream>
using namespace std;
//创建一个Person类
class Person{
public:
	//注意:类中默认存在一个无参构造构造函数且为空实现，这个构造函数一般可以省略不写，可以直接调用
    //注意:当类中编写了无参构造函数，则可以进行其他操作，例如:进行打印输出
	Person(){
        cout << "无参构造函数!" << endl;
	}
};

int main() {
	//创建Person实例化对象p时，编译器会自动调用无参构造函数
	Person p;
	system("pause");
	return 0;
}

• 对于带参数构造函数来说，如果一个类中存在带参构造器，那么默认存在无参构造函数如果在程序不编写，则不存在。如果编写，则仍然存在，我们可以在程序中看到
• 构造函数可以有参数，可以发生重载

#include<iostream>
using namespace std;
//创建一个Person类
class Person {
public:
	//无参（默认）构造函数
	Person() {
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int a) {
		age = a;
		cout << "有参构造函数!" << endl;
	}
};
int main() {
	//创建Person实例化对象p1时，编译器会自动调用无参构造函数
	Person p1;
    //创建Person实例化对象p2时，编译器会自动调用有参构造函数
    Person p1(10);
	system("pause");
	return 0;
}

析构函数语法：

~类名(){
    //空实现:指任何类中默认存在无参析构函数且函数体内不做任何操作，在销毁该类的对象时，编译器默认调用提供的无参析构函数且不做任何其他操作
}

注意事项:

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

代码示例:

#include<iostream>
using namespace std;
//创建一个Person类
class Person{
public:
	//构造函数
	Person()
	{
		cout << "Person的构造函数调用" << endl;
	}
	//析构函数
	~Person()
	{
		cout << "Person的析构函数调用" << endl;
	}

};
//定义全局函数test01，测试创建对象时，构造函数和析构函数的调用情况
void test01()
{
	//创建Person实例化对象p时，编译器会自动调用无参构造函数
	Person p;
}
int main() {
	//调用全局函数test01
    //注意:当调用全局函数test01时，创建对象P是一个局部对象，在test01函数调用完后，局部对象p的生命周期就结束了，GC会主动销毁对象p，编译器会在对象销毁前自动调用析构函数来清理对象中的数据
	test01();
	system("pause");
	return 0;
}

效果如图:

4.2.2 构造函数的分类及调用

两种分类方式：

1. 按参数分为： 有参构造和无参构造
2. 按类型分为： 普通构造和拷贝构造

三种调用方式：

1. 括号法
2. 显示法
3. 隐式转换法

示例：

#include<iostream>
using namespace std;

//创建一个Person类
class Person {
//成员变量
public:
	//年龄
	int age;
//成员方法
public:
	//无参构造函数
	Person() {
		cout << "Person类的无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int a) {
		age = a;
		cout << "Person类的有参构造函数!" << endl;
	}
	//拷贝构造函数
	//注意:使用const修饰引用类型的形参，防止形参改变实参
	Person(const Person &p) {
		//进行属性值拷贝
		age = p.age;
		cout << "Person类的拷贝构造函数!" << endl;
	}
	//析构函数
	~Person() {
		cout << "Person类的析构函数!" << endl;
	}
};
//测试
void test01() {
	//1.括号法，常用
	//1.1 默认调用无参构造函数
	Person p1;
	//1.2 调用有参构造函数
	Person p2(10);
	//1.3 调用拷贝构造函数
	Person p3(p2);
	cout << "p2.age = " << p2.age << endl;
	cout << "p3.age = " << p3.age << endl;
	//注意：调用无参构造函数不能加()，否则编译器认为这是一个函数声明
	Person p4();

	//2.显式法
	//2.1 默认调用无参构造函数
	Person p5;
	//2.2 调用有参构造函数
	Person p6 = Person(10);
	//2.3 调用拷贝构造函数
	Person p7 = Person(p6);
	//注意1:单独写就是匿名对象,创建匿名对象时，调用有参构造函数，对象创建完毕后，调用析构函数
	Person(10);
	cout << "匿名对象创建完之后调用析构函数后打印输出" << endl;
	//注意2：不能利用拷贝构造函数初始化匿名对象 编译器会认为Person (p7) == Person p7；对象的声明
	//Person(p7);

	//3 隐式转换法
	//3.1 调用有参构造函数
	Person p8 = 10; // <==> Person p8 = Person(10); 
	//3.2 调用拷贝构造函数
	Person p9 = p8; // <==> Person p9 = Person(p8); 
}
int main() {
	test01();
	system("pause");
	return 0;
}

4.2.3 拷贝构造函数调用时机

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

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

示例：

#include<iostream>
using namespace std;

class Person {
public:
	int m_Age;
public:
	Person() {
		cout << "Person类默认构造函数!" << endl;
		m_Age = 0;
	}
	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;
	}
};

//1.使用一个已经创建完毕的对象来初始化一个新对象
void test01() {
	//创建对象p1，调用有参构造函数
	Person p1(100); 
	//创建对象p2，调用拷贝构造函数，将对象p1中属性值拷贝给对象p2中相应的属性
	Person p2(p1); 
	cout << "p1.m_Age =" << p1.m_Age << endl;
	cout << "p2.m_Age =" << p2.m_Age << endl;
	//Person newman2 = p1; //拷贝构造

	//Person newman3;
	//newman3 = man; //不是调用拷贝构造函数，赋值操作
}

//2.值传递的方式给函数参数传值
//注意:形参对象为值传递的时，无法改变类中属性值
void doWork1(Person p) {
	cout << "p.m_Age = " << p.m_Age << endl;
	p.m_Age = 1000;
	cout << "p.m_Age = " << p.m_Age << endl;
}
void test02() {
	//创建对象p3，自动调用无参构造函数
	Person p3; 
	//注意:当调用doWork1(Person p1)函数时，形参中传入对象p，编译器自动进行将 Person p = p3 转换成 Person p = Person(p3)，调用了拷贝构造函数
	doWork1(p3);
	cout << "p3.m_Age = " << p3.m_Age << endl;
}

//3.以值方式返回局部对象
Person doWork2(){
	//创建对象p4，自动调用无参构造函数
	Person p4;
	cout << "p4对象的地址为:" << (int*)&p4 << endl;
	//注意:返回对象p4不是返回对象p4的地址，而是对象p4中的数据
	cout << "p4.m_Age = " << p4.m_Age << endl;
	p4.m_Age = 2000;
	cout << "p4.m_Age = " << p4.m_Age << endl;
	return p4;
}
void test03(){
	//注意:当调用doWork2()函数时，编译器自动进行将 Person p5 = p4 转换成 Person p5 = Person(p4)，调用了拷贝构造函数
	Person p5 = doWork2();
	cout << "p5对象的地址为:" << (int*)&p5 << endl;
	cout << "p5.m_Age = " << p5.m_Age << endl;
}

int main() {
	test01();
	cout<< "-------------------------------" << endl;
	test02();
	cout << "------------------------------" << endl;
	test03();
	system("pause");
	return 0;
}

效果如图:

4.2.4 构造函数调用规则

默认情况下，c++编译器至少给一个类添加4个函数，目前先学习以下3个函数

1. 默认构造函数(无参，函数体为空)
2. 默认析构函数(无参，函数体为空)
3. 默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

• 任何类中定义有参构造函数，c++不在提供默认无参构造函数，但是会提供默认拷贝构造函数

• 任何类定义拷贝构造函数，c++也不在提供默认无参构造函数

示例：

#include<iostream>
using namespace std;

class Person {
public:
	int m_Age;
public:
	//无参（默认）构造函数
	Person() {
		cout << "Person类无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int age) {
		m_Age = age;
		cout << "Person类有参构造函数!" << endl;
	}
	//析构函数
	~Person() {
		cout << "Person类析构函数!" << endl;
	}
};
void test01()
{
	Person p1(18);
	cout << "p1的年龄为： " << p1.m_Age << endl;
	//如果类中不编写拷贝构造函数，编译器会自动添加拷贝构造函数，并且做浅拷贝操作
	Person p2(p1);
	cout << "p2的年龄为： " << p2.m_Age << endl;
}

class People {
public:
	int m_Age;
public:
	//有参构造函数
	People(int age) {
		m_Age = age;
		cout << "People类有参构造函数!" << endl;
	}
	//析构函数
	~People() {
		cout << "People类析构函数!" << endl;
	}
};
void test02()
{
	//任何类中定义有参构造函数，c++不在提供默认无参构造函数，但是会提供默认拷贝构造函数
	//People p1;  编译器直接报错
	//创建对象p2，调用有参构造函数
	People p2(10); 
	cout << "p2的年龄为： " << p2.m_Age << endl;
	//如果类中不编写拷贝构造函数，编译器会自动添加拷贝构造函数，并且做浅拷贝操作
	People p3(p2);
	cout << "p3的年龄为： " << p3.m_Age << endl;
}

class Human {
public:
	int m_Age;
public:
	//拷贝构造函数
	Human(const Human &p) {
		m_Age = p.m_Age;
		cout << "Human拷贝构造函数!" << endl;
	}
	//析构函数
	~Human() {
		cout << "Human类析构函数!" << endl;
	}
};
void test03()
{
	//任何类定义拷贝构造函数，c++也不在提供默认无参构造函数,
	//Human p1; Human类中无默认构造函数，编译器直接报错
	//Human p2(10); Human类无有参默认构造函数，编译器直接报错
	//Human p6(p5); Human类有拷贝构造函数，但无法创建其他对象，导致拷贝构造函数也无法使用
	string str = "注意:任何类在使用拷贝构造函数时，都需要在类中编写一个无参构造函数或者有参构造函数";
	cout<< str << endl;
}

int main() {
	test01();
	cout << "-------------------------------" << endl;
	test02();
	cout << "-------------------------------" << endl;
	test03();
	system("pause");
	return 0;
}

效果如图:

4.2.5 深拷贝与浅拷贝

深浅拷贝是面试经典问题，也是常见的一个坑

浅拷贝：简单的赋值拷贝操作

深拷贝：在堆区重新申请空间，进行拷贝操作

示例：

#include<iostream>
using namespace std;
class Person {
public:
	//年龄
	int m_Age;
	//身高 注意:对于指针变量存储地址，不存储数据
	int* m_Height;
public:
	//无参构造函数
	Person() {
		cout << "Person类无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int age) {
		cout << "Person类有参构造函数!" << endl;
		m_Age = age;
	}
	//有参构造函数
	Person(int age, int height) {
		cout << "Person类有参构造函数!" << endl;
		m_Age = age;
		m_Height = new int(height);

	}
	//类中必须编写一个拷贝构造函数，c++中提供的拷贝构造函数是浅拷贝  
	Person(const Person &p) {
		cout << "Person类拷贝构造函数!" << endl;
		//如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
		m_Age = p.m_Age;
		//m_Height = p.m_Height; 编译器默认实现浅拷贝
		cout << "p.m_Height地址为:" << p.m_Height << endl;
		m_Height = new int(*p.m_Height);//深拷贝
		cout << "m_Height地址为:" << m_Height << endl;

	}
	//析构函数
	~Person() {
		//注意:析构函数将堆区开辟数据空间进行释放操作
		cout << "Person类析构函数!" << endl;
		if (m_Height != NULL)
		{
			delete m_Height;
			m_Height = NULL;
		}
	}
};
void test01(){
	//调用有参构造函数
	Person p1(25);
	cout << "p1的年龄： " << p1.m_Age << endl;
	//调用拷贝构造函数
	Person p2(p1);
	cout << "p2的年龄： " << p2.m_Age << endl;
}
void test02(){
	Person p1(18, 180);
	cout << "p1的年龄： " << p1.m_Age << " 身高： " << *(p1.m_Height) << endl;
	//调用拷贝构造函数
	//注意:一定要在类中编写一个拷贝构造函数，编译器提供的默认拷贝构造函数实现浅拷贝，会导致浅拷贝带来的重复释放堆区问题
	Person p2(p1);
	cout << "p2的年龄： " << p2.m_Age << " 身高： " << *(p2.m_Height) << endl;
}

int main() {
	//调用test01函数时，调用的是c++中默认提供的拷贝构造函数
	test01();
	//调用test01函数时，调用的是类中编写的拷贝构造函数
	test02();
	system("pause");
	return 0;
}

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

C++用类名创建对象和用new创建对象的区别

1. 用类名创建对象，是使用的stack空间，而使用new创建对象则使用的heap的空间;
2. 使用new创建对象，用完之后必须要delete。并且要把指针置为NULL;用类名创建的对象，使用完后，系统自动销毁，不会存在系统泄露的问题。
3. new创建的对象是使用指针来接受，一处初始化，多处使用。
4. 对于频繁使用的场合，不建议使用new来创建。

构造函数使用new注意事项：

1. 如果在构造函数使用new来初始化指针，则在析构函数使用delete

2. new和delete要对应。new对应delete,new [] 对应delete []

3. 如果有多个构造函数，必须以相同的方式使用new，因为只有一个析构函数。默认构造函数将它设置为null或0

4.2.6 初始化列表

作用：

C++提供了初始化列表语法，用来给属性初始化

语法：构造函数():属性1(值1),属性2(值2)... {}

示例：

#include<iostream>
using namespace std;
class Person {
public:
	int m_A;
	int m_B;
	int m_C;
public:
	//第一种方式:有参构造函数进行属性初始化
	//Person(int a, int b, int c) {
	//	m_A = a;
	//	m_B = b;
	//	m_C = c;
	//}
	//第二种方式:无参构造函数初始化列表方式进行属性初始化
	//注意:这种方式属性的值无法随意改动，只能是固定值
	Person() :m_A(10), m_B(20), m_C(30) {};
	//第三种方式:有参构造函数初始化列表方式进行属性初始化
	//注意:有参构造函数初始化列表方式本质就是第一种有参构造函数进行属性初始化，所以，两者不能同时存在
	Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c) {}
};
//测试
void test01() {
	Person p1(1, 2, 3);
	cout << "mA = " << p1.m_A << endl;
	cout << "mB = " << p1.m_B << endl;
	cout << "mC = " << p1.m_C << endl;
}
void test02() {
	Person p2;
	cout << "mA = " << p2.m_A << endl;
	cout << "mB = " << p2.m_B << endl;
	cout << "mC = " << p2.m_C << endl;
}
void test03() {
	Person p3(100,200,300);
	cout << "mA = " << p3.m_A << endl;
	cout << "mB = " << p3.m_B << endl;
	cout << "mC = " << p3.m_C << endl;
}
int main() {
	test01();
	test02();
	test03();
	system("pause");
	return 0;
}

4.2.7 类对象作为类成员

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

例如：

class A {}
class B
{
    A a；
}

B类中有对象A作为成员，A为对象成员

那么当创建B对象时，A与B的构造和析构的顺序是谁先谁后？

示例：

#include<iostream>
using namespace std;
//定义一个Phone类
class Phone{
public:
	//手机型号名称
	string m_PhoneName;
public:
	Phone(string name)
	{
		m_PhoneName = name;
		cout << "Phone类中有参构造函数" << endl;
	}
	~Phone()
	{
		cout << "Phone类中析构函数" << endl;
	}
};
//定义一个Person类
class Person{
public:
	//姓名
	string m_Name;
	//手机
	Phone m_Phone;
public:
	//有参构造函数通过初始化列表可以进行属性初始化
	//注意:Phone m_Phone = pName <==>Phone m_Phone = Phone(pName),利用了隐式转换法，编译器自动调用了Phone类中的有参构造函数
	Person(string name, string pName) :m_Name(name), m_Phone(pName){
		cout << "Person类有参构造函数" << endl;
	};

	~Person(){
		cout << "Person析构" << endl;
	};

	void playGame(){
		cout << m_Name << " 使用" << m_Phone.m_PhoneName << " 牌手机! " << endl;
	};
};
//测试
void test01()
{
	//当类中成员是其他类对象时，我们称该成员为 对象成员
	//构造的顺序是:先调用对象成员的构造函数，再调用本类构造函数
	//析构的顺序是:先调用本类析构函数，再调用对象成员的析构函数
	Person p("张三", "苹果X");
	p.playGame();
}

int main() {
	test01();
	system("pause");
	return 0;
}

结论: 当A类中成员是B类对象时，A与B的构造和析构的顺序如下:

1. 构造的顺序是:先调用B类对象中的构造函数，再调用A类中构造函数
2. 析构的顺序是:先调用A类析构函数，再调用B类对象的析构函数

4.2.8 静态成员

静态成员分为：

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

静态成员指在成员变量和成员函数前加上关键字static进行修饰，称为静态成员

示例1: 静态成员变量

#include<iostream>
using namespace std;
class Person {
public:
	//1.定义静态成员变量，
	//注意:
	//①.静态成员变量在编译阶段分配内存
	//②.在类中声明，在类外必须初始化，否则无法进行链接而导致编译无法通过！
	static int m_A; 
private:
	//4.当静态变量在private权限下，在类外两种方式都无法访问！！！
	static int m_B; //静态成员变量也是有访问权限的
};
//2.静态变量类内声明，类外初始化
int Person::m_A = 10;
int Person::m_B = 10;

void test01()
{
	//静态成员变量两种访问方式
	//第一种方式:通过类创建对象，对象.静态变量名进行操作，写读可写
	Person p1;
	p1.m_A = 100;
	cout << "p1.m_A = " << p1.m_A << endl;
	p1.m_A = 200;
	cout << "p1.m_A = " << p1.m_A << endl;
	Person p2;
	//3.所有类创建的对象共享同一份数据
	cout << "p2.m_A = " << p2.m_A << endl;
	//第二种方式:通过类名::静态变量名进行操作，可读可写
	cout << "Person::m_A = " << Person::m_A << endl;
	Person::m_A = 2000;
	cout << "Person::m_A = " << Person::m_A << endl;
	//私有权限访问下的静态变量类外无法访问
	//cout << "m_B = " << Person::m_B << endl; 编译直接报错
}

int main() {
	test01();
	system("pause");
	return 0;
}

总结:

• 静态成员变量在编译阶段分配内存
• 静态成员变量在类中声明，在类外必须初始化，否则无法进行链接而导致编译阶段无法通过！
• 非private权限下的静态成员变量两种访问方式：
  • 通过类创建对象，对象.静态成员变量名进行操作，写读可写
  • 通过类名::静态成员变量名进行操作，可读可写
• pirvate权限定义的静态成员变量类外上述两种方式都无法访问
• 所有该类创建的对象或类名:::静态成员变量名共享同一份静态成员变量资源

示例2: 静态成员函数

#include<iostream>
using namespace std;
class Person{
public:
	//3.定义两个成员变量，静态成员变量注意需要在类外进行初始化
	static int m_A ; //静态成员变量
	int m_B; //成员变量
public:
	//1.在public权限下定义一个静态成员函数
	static void function1(){
		cout << "静态函数function1调用" << endl;
	}
	static void function2() {
		cout << "静态函数function2调用" << endl;
		//注意点如下:
		//①.静态成员函数中只可以访问静态成员，且对静态成员变量可以进行可读可写，对静态成员函数可以进行操作！
		//②.静态成员函数不可以访问非静态成员
		cout << "m_A 初始值为: " << m_A << endl;
		m_A = 100;
		cout << "m_A 修改值为: " << m_A << endl;
		//cout << "m_B 修改值为: " << m_B << endl;//编译器直接报错，无法访问成员函数
		function1();//调用静态成员函数function1
		//function3();//编译器直接报错，无法访问调用成员函数function3
	}
	//4.在public权限下定义一个非静态成员函数
	void function3() {
		cout << "静态函数function3调用" << endl;
	}
private:
	//6.private权限下定义静态成员函数
	static void function4(){
		cout << "function4调用" << endl;
	}
};
//静态成员变量m_A类外进行初始化
int Person::m_A = 10;

//测试
void test01(){
	//2.静态成员变量两种访问方式
	//注意:两种方式访问静态成员函数均为共享同一个函数
	//第一种方式:通过类创建对象后，以对象.静态成员函数名方式进行操作
	Person p1;
	p1.function1();
	//第二种方式:通过类名::静态成员函数名方式进行操作
	Person::function1();
	//5.调用静态成员函数function2
	//注意点如下:
	//①.静态成员函数中只可以访问静态成员，且对静态成员变量可以进行可读可写，对静态成员函数可以进行操作！
	//②.静态成员函数不可以访问非静态成员
	Person::function2();

	//注意:private权限下的静态成员函数,上述两种方式无法访问！！！
	//Person::function4(); //编译器直接报错，无法访问private权限下的静态成员函数
}
int main() {
	test01();
	system("pause");
	return 0;
}

总结:

• 在非private权限下的静态成员函数有两种方式进行操作：
  • 通过类创建对象，对象.静态函数名进行操作
  • 通过类名::静态函数名进行操作
• pirvate权限定义的静态成员函数类外上述两种方式都无法访问
• 所有该类创建的对象或类名:::静态成员函数名共享同一份静态成员函数