• 黑马C++ 02 核心3 —— 类和对象__对象的初始化和清理(重难点)

    • 生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全
    • C++中的面向对象来源于生活，每个对象也都会有初始设置以及 对象销毁前的清理数据的设置

    文章目录

    1 构造函数(初始化)和析构函数(清理)

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

    • 一个对象或者变量没有初始状态，对其使用后果未知
    • 同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

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

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

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

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

    构造函数语法：类名(){}

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

    析构函数语法： ~类名(){}

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

//对象的初始化和清理
class Person
{
public:
	//1. 构造函数(写作用域)，进行初始化操作
	//没有返回值，不用写void
	//函数名 与类的名称相同
	//构造函数可以有参数，可以发生重载
	//创建对象时，构造函数会自动调用，而且只调用一次
	Person()
	{
		cout << "Person 构造函数的调用" << endl;

	}
	//2. 析构函数  进行清理操作
	//没有返回值 不写void
	//函数名和类名相同，在名称前加~
	//析构函数不可以有参数，不可以发生重载
	//对象在销毁前，会自动调用析构函数，而且只会调用一次
	~Person()
	{
		cout << "Person 析构函数调用" << endl;
	}

};

//析构和构造都是必须有的实现，如果我们自己不提供，编译器会提供一个空实现的构造和析构函数(没有代码)
void test01()
{
	Person p;//局部变量，在栈上的数据，test01执行完毕后自动释放这个对象
}


int main()
{
	test01();//有构造和析构，在函数调用完之后，对象就会释放，调用析构函数

	cout << endl;

	Person p;//只有构造没有析构，因为对象没有释放，所以没有析构

	system("pause");
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 在main函数中 Person p执行完会先调用构造函数，当最后return 0执行结束才会调用析构函数(对象函数结束销毁就会执行析构函数)
    • test01()中执行完Person p后，会立马释放这个对象，执行析构函数

    在这里插入图片描述

    2 构造函数的分类及调用

    2.1 分类 —— 按参数

    • 无参构造(默认)
    //无参构造函数
	Person()
	{
		cout << "Person的无参构造函数的调用" << endl;
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 有参构造
    //有参构造函数
	Person(int a)
	{
		age = a;
		cout << "Person的有参构造函数的调用" << endl;
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    2.2 分类 —— 按类型(拷贝构造!!! 加引用)

    • 普通构造
    • 拷贝构造
    //拷贝构造函数
	Person(const Person& p)//拷贝一模一样的数据出来
	{
		//将传入的人身上所有属性，拷贝到我身上
		age = p.age;
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    2.3 调用 —— 括号法(推荐)

    • 括号法
    	//1.括号法
	Person p;//默认构造函数调用
	Person p0(10);//有参构造函数
	Person p1(p0);//拷贝构造函数
	cout << "p0 年龄为： " << p0.age << endl;//显示为10
	cout << "p1 年龄为： " << p1.age << endl;//显示为10
	cout << endl;

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 注意事项1：调用默认构造函数时，不要加小括号()；因为下面这行代码，编译器会认为是函数的声明，不会认识是在创建对象，Person p1()

    2.4 调用 —— 显示法

    	//2.显示法
	Person p6;//默认构造
	Person p2 = Person(20);//有参构造
	Person p3 = Person(p2);//拷贝构造
	cout << "p2 年龄为： " << p2.age << endl;//显示为20
	cout << "p3 年龄为： " << p3.age << endl;//显示为20
	cout << endl;

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • Person(10) 匿名对象，特点：当前行执行结束后，系统会立即回收匿名对象
    • 注意事项2：不要利用拷贝函数初始化匿名对象，编译器会认为Person (p3) == Person p3;对象声明；Person(p3) —— 用拷贝函数初始化匿名对象

    2.5 调用 —— 隐式转换法

    	//3.隐式转换法
	Person p7;// 默认构造
	Person p4 = 30;//相当于	Person p4 = Person(10);有参构造 
	Person p5 = p4;//拷贝构造
	cout << "p4 年龄为： " << p4.age << endl;//显示为30
	cout << "p5 年龄为： " << p5.age << endl;//显示为30
	cout << endl;

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 总的程序
    #include
using namespace std;

//1.构造函数的分类及调用
//分类
//  按照参数分类   无参构造(默认构造)	有参构造
//  按照类型分类   普通构造		拷贝构造
class Person
{
public:
	//无参构造函数
	Person()
	{
		cout << "Person 无参构造函数的调用" << endl;
	}

	//有参构造函数
	Person(int a)
	{
		age = a;
		cout << "Person 有参构造函数的调用" << endl;
	}

	//拷贝构造函数
	Person(const Person& p)//拷贝一模一样的数据出来
	{
		//将传入的人身上所有属性，拷贝到我身上
		age = p.age;
	}

	//析构函数调用
	~Person()
	{
		cout << "Person 析构函数调用" << endl;
	}

	int age;
};

//调用(三种方法)
void test01()
{
	//1.括号法
	Person p;//默认构造函数调用
	Person p0(10);//有参构造函数
	Person p1(p0);//拷贝构造函数

	//注意事项1
	//调用默认构造函数时，不要加小括号()
	//因为下面这行代码，编译器会认为是函数的声明，不会认识是在创建对象
	//Person p1();

	cout << "p0 年龄为： " << p0.age << endl;//显示为10
	cout << "p1 年龄为： " << p1.age << endl;//显示为10
	cout << endl;

	//2.显示法
	Person p6;//默认构造
	Person p2 = Person(20);//有参构造
	Person p3 = Person(p2);//拷贝构造
	cout << "p2 年龄为： " << p2.age << endl;//显示为20
	cout << "p3 年龄为： " << p3.age << endl;//显示为20
	cout << endl;

	//Person(10);//匿名对象，特点：当前行执行结束后，系统会立即回收匿名对象
	// cout << "aaaaa" << endl;
	
	//注意事项2
	//不要利用拷贝函数初始化匿名对象，编译器会认为Person (p3) == Person  p3;对象声明
	//Person(p3);(会出错)

	//3.隐式转换法
	Person p7;// 默认构造
	Person p4 = 30;//相当于	Person p4 = Person(10);有参构造 
	Person p5 = p4;//拷贝构造
	cout << "p4 年龄为： " << p4.age << endl;//显示为30
	cout << "p5 年龄为： " << p5.age << endl;//显示为30
	cout << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87

    在这里插入图片描述

    • 结论：每次调用完函数，最后都会调用析构函数

    3 拷贝构造函数调用时机(3种情况)

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

    3.1 使用已经创建完毕的对象来初始化一个新对象

    //1.使用一个已经创建完毕的对象来初始化一个新对象
void test01()
{
	Person p1(20);// 有参构造
	Person p2(p1);// 拷贝构造

	cout << "p2 年龄为：" << p2.m_age << endl;// 20
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    在这里插入图片描述

    3.2 值传递的方式给函数参数传值

    //2.值传递的方式给函数参数传值
void doWork(Person p)// 值传递拷贝出临时的副本，不会影响下面的数据
{

}

void test02()
{
	Person p3;// 默认构造
	doWork(p3);// 实参调用形参时会调用拷贝构造函数
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    在这里插入图片描述

    3.3 以值方式返回局部对象(难点)

    //3.值方式返回局部对象，局部对象 函数执行完之后，就会被释放掉
Person doWork2()
{
	Person p1;// 局部对象，默认构造，通过拷贝p1这个新的对象给外面
	cout << (int*)&p1 << endl;
	return p1;// p1是Person类型，通过第1行p1拷贝一个新的对象，返回给test03，拷贝构造
}

void test03()
{
	Person p = doWork2();// 创建局部对象
	cout << (int*)&p << endl;//p 和 p1不是一个
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    在这里插入图片描述

    #include
using namespace std;

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

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;
	}

	int m_age;
};


//1.使用一个已经创建完毕的对象来初始化一个新对象
void test01()
{
	Person p1(20);// 有参构造
	Person p2(p1);// 拷贝构造

	cout << "p2 年龄为：" << p2.m_age << endl;// 20
}

//2.值传递的方式给函数参数传值
void doWork(Person p)// 值传递拷贝出临时的副本，不会影响下面的数据
{

}

void test02()
{
	Person p3;// 默认构造(无参)
	doWork(p3);// 实参调用形参时会调用拷贝构造函数，拷贝构造
}


//3.值方式返回局部对象，局部对象 函数执行完之后，就会被释放掉
Person doWork2()
{
	Person p1;// 局部对象，默认构造，通过拷贝p1这个新的对象给外面
	cout << (int*)&p1 << endl;
	return p1;// p1是Person类型，通过第1行p1拷贝一个新的对象，返回给test03，拷贝构造
}

void test03()
{
	Person p = doWork2();// 创建局部对象
	cout << (int*)&p << endl;//p 和 p1不是一个
}

int main()
{
	test01();
	cout << endl;
	test02();
	cout << endl;
	test03();

	system("pause");
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81

    在这里插入图片描述

    4 构造函数调用规则

    默认情况下，c++编译器至少给一个类添加3个函数

    1. 默认构造函数(无参，函数体为空)

    2. 默认析构函数(无参，函数体为空)

    3. 默认拷贝构造函数，对属性进行值拷贝

    构造函数调用规则如下

    • 如果用户定义有参构造函数，c++不再提供默认无参构造，但是会提供默认拷贝构造
    • 如果用户定义拷贝构造函数，c++不会再提供其他构造函数
    • 如果代码提供有参构造，编译器就不提供无参构造
    • 如果代码提供拷贝构造，编译器就不提供有参、无参构造
    #include
using namespace std;

//构造函数的调用规则
//1. 创建一个类，C++编译器会给每个类都添加至少3个函数
//默认构造 (空实现)
//析构函数 (空实现)
//拷贝函数 (值拷贝)

//2. 如果我们写了有参构造函数，编译器就不再提供默认构造，依然提供拷贝构造
//3. 如果我们写了拷贝构造函数，编译器就不再提供其他普通构造函数

class Person
{
public:
	//无参（默认）构造函数
	Person()
	{
		cout << "Person 默认构造函数调用" << endl;
	}
	//有参构造函数
	Person(int age)
	{
		m_age = age;
		cout << "Person 有参构造函数调用" << endl;
	}
	//拷贝构造函数
	Person(const Person& p)
	{
		m_age = p.m_age;
		cout << "Person 拷贝构造函数调用" << endl;
	}
	//析构函数
	~Person() {
		cout << "Person 析构函数调用" << endl;
	}

public:
	int m_age;
};

void test01()//test01执行完之后，p1和p2就被释放掉，执行它们的析构函数
{
	Person p1;//默认构造函数调用
	p1.m_age = 18;
	cout << "p1 年龄为: " << p1.m_age << endl;
	Person p2(p1);//拷贝构造函数调用
	cout << "p2 年龄为: " << p2.m_age << endl;
}

void test02()
{
	Person p;
}

int main()
{
	test01();
	cout << endl;

	test02();

	system("pause");
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65

    在这里插入图片描述

    5 深拷贝和浅拷贝(难点)

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

    • 浅拷贝：简单的赋值拷贝操作，如果利用编译器提供的拷贝构造函数，会做浅拷贝操作。就是程序提供的等号赋值工作
    • 直接使用 Person p2(p1) 使用编译器的浅拷贝
    • 只有有参构造和无参构造的话，编译器会执行
    • 浅拷贝带来的问题是：堆区的内存重复释放
    • 深拷贝：在堆区重新申请空间，进行拷贝操作
    • 深拷贝指针指向的堆区是不同的，在做释放时就不会出现错误。
      在这里插入图片描述
    • 栈的规则是先进后出，所以先释放p2，再释放p1，释放p2时已经释放堆区数据，释放p1时又在同一个堆区释放数据，造成数据释放重复

    程序

    • 自己设置拷贝构造函数
    	// 自己实现拷贝构造函数，解决浅拷贝带来的问题 
	Person(const Person& p)
	{
		cout << "Person 拷贝构造函数调用 " << endl;

		// 如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
		m_age = p.m_age;
		// m_height = p.m_height;这是浅拷贝，编译器默认实现就是这行代码
		// 深拷贝操作 —— 重新在堆区创建一块内存
		m_height = new int(*p.m_height);// 解引用重新在堆区申请一块内存

	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 析构函数
    	// 析构函数 —— 作用是释放干净堆区的代码
	~Person()
	{
		// 析构代码，将堆区开辟的数据做释放操作
		cout << "析构函数调用" << endl;
		if (m_height != NULL)
		{
			delete m_height;// 利用delete释放干净
			m_height = NULL;// 防止野指针出现，置空操作
		}
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 总结：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题
    #include
using namespace std;

// 深拷贝和浅拷贝
// 浅拷贝：简单的赋值拷贝操作
// 深拷贝：在堆区重新申请空间，进行拷贝操作
class Person
{
public:
	// 无参构造函数(默认)
	Person()
	{
		cout << "Person 无参构造函数调用" << endl;
	}
	// 有参构造函数
	Person(int age, int height)
	{
		cout << "Person 有参构造函数调用" << endl;

		m_age = age;
		m_height = new int(height);
		// 利用new把身高创建在堆区，用指针接收堆区的数据
		// 堆区数据由程序员手动开辟和释放
	}

	// 自己实现拷贝构造函数，解决浅拷贝带来的问题 
	Person(const Person& p)
	{
		cout << "Person 拷贝构造函数调用 " << endl;

		// 如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
		m_age = p.m_age;
		// m_height = p.m_height;这是浅拷贝，编译器默认实现就是这行代码
		// 深拷贝操作 —— 重新在堆区创建一块内存
		m_height = new int(*p.m_height);// 解引用重新在堆区申请一块内存

	}

	// 析构函数 —— 作用是释放干净堆区的代码
	~Person()
	{
		// 析构代码，将堆区开辟的数据做释放操作
		cout << "析构函数调用" << endl;
		if (m_height != NULL)
		{
			delete m_height;// 利用delete释放干净
			m_height = NULL;// 防止野指针出现，置空操作
		}
	}

	int m_age;// 年龄
	int* m_height;// 身高用指针，目的是把身高的数据开辟到堆区
};

void test01()// 栈的规则是先进后出，所以先释放p2，再释放p1
{
	// test01()执行完了，就可以释放p2，p1，销毁堆区数据
	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;
}
// 浅拷贝的问题是堆区的内存被重复释放，先被p1释放，再被p2释放
// 浅拷贝问题用深拷贝解决

int main()
{
	test01();

	system("pause");
	return 0;
}
// 如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76

    6 初始化列表

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

    传统方式利用构造函数初始化代码

    #include
using namespace std;

// 初始化列表
class Person {
public:

	// 传统方式初始化 利用构造函数初始化
	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);
	cout << "m_A: " << m_A << endl;
	cout << "m_B: " << m_B << endl;
	cout << "m_C: " << m_C << endl;
}

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    用初始化列表初始化属性

    #include
using namespace std;

// 初始化列表
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) {}
	void PrintPerson() {
		cout << "m_A = " << m_A << endl;
		cout << "m_B = " << m_B << endl;
		cout << "m_C = " << m_C << endl;
	}

private:
	int m_A;
	int m_B;
	int m_C;
};

int main() {

	Person p(1, 2, 3);
	p.PrintPerson();

	system("pause");
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    在这里插入图片描述

    7 类对象作为类成员

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

    class A {}
class B
{
    A a；
}

    • 1
    • 2
    • 3
    • 4
    • 5

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

    • 当类中成员是其他类对象时，我们称该成员为 对象成员
    • 构造的顺序是 ：先调用对象成员的构造，再调用本类构造
    • 析构顺序与构造相反
    #include
#include// string 头文件
using namespace std;

// 类对象作为类成员 —— 对象成员

// 手机类 —— 人这个类的成员
class Phone
{
public:
	// 有参构造函数
	Phone(string pName)
	{
		cout << "Phone 有参构造函数调用" << endl;
		m_PName = pName;
	}

	~Phone()
	{
		cout << "Phone 析构函数调用" << endl;
	}

	// 手机品牌名称
	string m_PName;
};

// 人类
class Person
{
public:

	// Phone m_Phone = pName 隐式转换法，利用字符串给对象赋值
	// 初始化列表，相当于写了 Phone m_Phone = pName
	Person(string name, string pName) :m_Name(name), m_Phone(pName)
	{
		cout << "Person 构造函数调用" << endl;
	}

	~Person()
	{
		cout << "Person 析构函数调用" << endl;
	}

	// 姓名
	string m_Name;
	// 手机
	Phone m_Phone;// 设计手机类,phone是对象类型
};

// 当其他类对象作为本类成员，构造时先构造其他类对象（先phone再person），再构造自身。析构的顺序与构造相反

// 当类中成员是其他类对象时，我们称该成员为 对象成员
// 构造的顺序是 ：先调用对象成员的构造，再调用本类构造
// 析构顺序与构造相反

void test01()
{
	Person p("张三", "苹果MAX");

	cout << p.m_Name << "拿着" << p.m_Phone.m_PName << endl;
}

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68

    8 静态成员(成员变量和函数加static，重点难点)

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

    • 静态成员变量

      • 所有对象共享同一份数据
      • 在编译阶段分配内存(分配到全局区)
      • 类内声明，类外初始化
      • 静态成员变量 —— 必须在类内声明，在类外初始化
      • 静态成员变量也是有访问权限的,私有不可访问

    • 静态成员函数

      • 所有对象共享同一个函数
      • 静态成员函数只能访问静态成员变量

    • 静态成员变量访问方式

      • 通过对象进行访问
      • 通过类名进行访问

    8.1 静态成员变量

    #include
using namespace std;

class Person
{
public:

	static int m_A; // 静态成员变量

	// 静态成员变量特点：
	// 1 在编译阶段分配内存(全局区)
	// 2 类内声明，类外初始化
	// 3 所有对象共享同一份数据

private:
	static int m_B; // 静态成员变量也是有访问权限的
};

int Person::m_A = 100;// Person下的静态变量类外声明
int Person::m_B = 300;

void test01()
{
	Person p;
	cout << p.m_A << endl;// 100

	Person p2;
	p2.m_A = 200;

	cout << p.m_A << endl;// 200 因为所有对象共享同一份数据 
}

void test02()
{
	// 静态成员变量两种访问方式

	// 1、通过对象进行访问
	Person p1;
	p1.m_A = 100;
	cout << "p1.m_A = " << p1.m_A << endl;

	Person p2;
	p2.m_A = 200;
	cout << "p1.m_A = " << p1.m_A << endl; // 共享同一份数据
	cout << "p2.m_A = " << p2.m_A << endl;

	// 2、通过类名
	cout << "m_A = " << Person::m_A << endl;

	//cout << "m_B = " << Person::m_B << endl; // 私有权限访问不到
}

int main() {

	test01();

	system("pause");
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59

    8.2 静态成员函数

    #include
using namespace std;

// 静态成员函数特点
// 1 所有对象共享同一个函数
// 2 静态成员函数只能访问静态成员变量
class Person
{
public:
	// 静态成员函数
	static void func()
	{
		m_A = 100;// 静态成员函数可以访问 静态成员变量(共享)
		//m_B = 200;// 静态成员函数 不可以访问 非静态成员变量，无法区分到底是哪个对象的m_B的属性
		cout << "static void func 调用" << endl;
	}

	// 静态成员变量特点
	// 1 在编译阶段分配内存
	// 2 类内声明，类外初始化
	// 3 所有对象共享同一份数据
	// 静态成员变量 —— 必须在类内声明，在类外初始化
	static int m_A; // 静态成员变量
	int m_B;// 非静态成员变量

	// 静态成员函数也是有访问权限的,私有不可访问
private:
	static void func2()
	{
		cout << "static void func2 调用" << endl;
	}
};

int Person::m_A = 10;// 静态成员变量类外的初始化
// int Person::m_B = 10; 

void test01()
{
	// 静态成员函数两种访问方式
	// 1. 通过对象进行访问
	Person p;
	p.func();

	// 2. 通过类名进行访问
	Person::func();
	// Person::func2();//类外访问不到私有的静态成员函数
}

int main()
{
	test01();

	system("pause");
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
  • 相关阅读:
    Oracle 执行计划查看方法汇总及优劣比较
    数说故事与暨南大学达成“大数据+AI+传媒”全面战略合作
    PL/SQL+cpolar公网访问内网Oracle数据库
    不小心格式化了硬盘怎么恢复？
    景联文科技：高质量AI数据标注助力大语言模型训练，推动人工智能落地应用
    [2023.09.13]: Rust Lang，避不开的所有权问题
    CH341/CH340Linux驱动使用教程
    【瑞吉外卖】day10：缓存验证码、菜品、套餐信息以及推送到gitee
    UI框架、css预处理与vuex状态管理
    HC小区管理系统房屋收费功能说明
  • 原文地址：https://blog.csdn.net/qq_42731062/article/details/126445199