C++核心编程（黑马程序员笔记）

writespace_x

已于 2023-11-10 10:35:11 修改

阅读量254

点赞数 4

文章标签： c++

于 2023-04-25 14:56:11 首次发布

本文链接：https://blog.csdn.net/qq_46210601/article/details/130208696

版权

C++核心编程

一、程序的内存模型
二、C++中的引用
三、函数提高
四、类与对象

一、程序的内存模型

（1）内存四区

1.内存分区模型

C++程序在执行时，将内存大方向划分为4个区域
*代码区：存放函数体的二进制代码，由操作系统进行管理的
*全局区：存放全局变量和静态变量以及常量
*栈区：由编译器自动分配释放，存放函数的参数值、局部变量等
*堆区：由程序员分配和释放，若程序员不释放，程序结束后由操作系统回收

2.内存四区意义：

不同区域存放的数据，赋予不同的生命周期，给我们更大的灵活编程

3.程序运行前

在程序编译后，生成了exe可执行程序，未执行该程序前分为两个区域

代码区：

1.存放CPU执行的机器指令
2.代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可。
3.代码区是只读的，使其只读的原因是防止程序意外地修改了它的指令

全局区：

1.全局变量和静态变量存放在此。
2.全局区还包含了常量区，字符串常量和其他常量也存放在此。
3.该区域的数据在程序结束后由操作系统释放
全局变量、静态变量（static关键字）、常量（字符串常量、const修饰的全局变量（全局常量））在全局区
局部变量，const修饰的局部变量（局部常量）不在全局区

// 此时输出a的地址，且以十进制输出，也就是 (int)
cout << "局部变量a的地址为：" << (int)&a << endl;

//静态变量 在普通变量前面加上static，属于静态变量
static int a = 10;

//常量分为 1.字符串常量 2.const修饰的变量
//字符串常量 "Hello world"
//const修饰的变量 分为 1.const修饰的全局变量 2.const修饰的局部变量

4.程序运行后

栈区：

由编译器自动分配释放，存放函数的参数值、局部变量等

注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放

int* func() //形参数据也会放在栈区
{
	int a = 10; //局部变量，存放在栈区，栈区的数据在函数执行完后自动释放
	return &a; //返回局部变量的地址
}
int main()
{
	//接收func函数的返回值
	int* p = func()
	cout << *p << endl; //编译器给我们做了一个保留，第一次可以打印正确的数字，是因为编译器做了保留
	cout << *p << endl;第二次这个数据就不再保留了
}

堆区：

由程序员分配释放，若程序员不释放，程序结束后由操作系统回收

在C++中主要利用new在堆区开辟内存

int* func()
{
	//利用new关键字，可以将数据开辟到堆区
	//指针 本质也是局部变量，放在栈上，指针保存的数据是放在堆区
	//栈上存放着地址编号，而这个地址编  号指着是一个堆区的数据
	int* p = new int(10);
	return p;
}
int main()
{
//在堆区开辟数据  
	int* p = func();
	cout << *p << endl;
}

（2）new操作符

1.C++中利用new操作符在堆区开辟数据
2.堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符delete
3.语法：new 数据类型
4.利用new创建的数据，会返回该数据对应的类型的指针

// 1.new的基本语法
int* func()
{
	//在堆区创建整型数据
	//new返回的是，该数据类型的指针
	int* p = new int(10);
	return p;
}
void test01()
{
	int* p = func();
	cout << *p << endl;
	//堆区的数据由程序员管理开辟，程序员管理释放
	//如果想释放堆区的数据，利用关键字delete；
	delete p；
	cout << *p << endl; //此时内存已经被释放，引发了异常，读取访问权限冲突
}

//2.在堆区利用new开辟数组
void test02()
{
//创建10整型数据的数组，在堆区
//此时返回的是连续的空间
	int* arr = new int[10];
	for(int i = 0; i < 10; i++)
	{
		arr[i] = i + 100;
	}
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i] << endl;
	}
	//释放堆区数组
	//释放数组的时候，要加[]才可以
	delete[] arr;
}	
int main()
{
	test02();
}

二、C++中的引用

（1）引用的基本使用

作用：给变量起别名
语法：数据类型 &别名= 原名

int a = 10; //此时是通过变量名a来改变内存中的值
//创建引用
int &b = a;//b是a的别名，所以两个变量访问的内存是一样的
b = 20;
cout << a << endl; //此时输出的值也是20

（2）引用的注意事项

1.引用必须初始化
2.引用在初始化后，不可以改变

int main()
{
	int a = 10;
	int b = 20;
	//int &c; 这个是错误的，引用必须要初始化
	int &c = a;//一旦初始化后，就不可以更改
	c = b;//这是赋值操作，不是更改引用
}

（3）引用做函数参数

1.作用：函数传参时，可以利用引用的技术让形参修饰实参
2.优点：可以简化指针修改实参

//1、值传递
void mySwap01(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;//形参确实发生改变
}
int main()
{
	int a = 10;
	int b = 20;
	mySwap01(a,b);//值传递，形参不会修饰实参
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
}

//2、地址传递
void mySwap02(int* a, int* b)
{
	int temp = *a;
	*a = *b;
	*b = temp;
}
int main()
{
	int a = 10;
	int b = 20;
	mySwap02(&a,&b);//地址传递，形参会修饰实参的
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
}

//3、引用传递
void mySwap03(int &a, int &b)
{
	int temp = a;
	a = b;
	b = temp;
}
int main()
{
	int a = 10;
	int b = 20;
	//mySwap03函数中的&a，a就是主函数中的a的别名，只是别名和原名起的一样
	//对mySwap03中的a操作，就是对主函数中的a操作
	mySwap03(a, b);//引用传递，形参会修饰实参的
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
}

总结：通过引用参数产生的效果同按地址传递是一样的，引用的语法更清楚简单

（4）引用做函数返回值

作用：引用是可以作为函数的返回值存在的
注意：不要返回局部变量引用
用法：函数调用作为左值

//1.返回局部变量引用
int& test01()//用引用的方式进行返回
{
	int a = 10;//局部变量，存放在四区中的栈区
	return a;
}
int main()
{
	int &ref = test01();
	cout << "ref = " << ref << endl;//第一次结果正确，是因为编译器做了保留
	cout << "ref = " << ref << endl;//第一次是正常的值，但第二次就是乱值了，因为a的内存已经释放
}

//2.返回静态变量引用
int& test02()
{
	static int a = 20;//静态变量，存放在全局区，全局区上的数据在程序结束后系统释放
	return a;
}
int main()
{
	int &ref2 = test02();
	cout << "ref2 = " << ref2 << endl;
	cout << "ref2 = " << ref2 << endl;
}

//3.函数的调用可以作为左值
int main()
{
	int &ref2 = test02();
	test02() = 1000;//test02把变量a返回，所以函数的调用可以作左值
	cout << "ref2 = " << ref2 << endl;//此时ref2是a的别名，所以输出时，ref2值为1000
}

如果函数的返回值是引用，这个函数调用可以作为左值

（5）引用的本质

引用的本质：引用的本质在c++内部实现是一个指针常量

//发现是引用，转换为int* const ref = &a;
void func(int& ref)
{
	ref = 100;//ref是引用，转换为*ref = 100
}
int main()
{
	int a = 10;	
	int& ref = a;//自动转化为int* const ref = &a;指针常量是指针指向不可改，也说明为什么引用不可更改
	ref = 20;//内部发现ref是引用，自动帮我们转化为: *ref = 20;
	cout << "a: " << a << endl;
	cout << "ref: " << ref << endl;
	func(a);
	return 0;
}

（6）常量引用

作用：常量应用主要用来修饰形参，防止误操作
在函数形参列表中，可以加const修饰形参，防止形参改变实参

//常量引用
int main()
{
	int& ref = 10;//false,引用必须引一块合法的内存空间
	
	const int& ref = 10;//true
	//加上const之后，编译器将代码修改int temp = 10; const int& ref = temp;
	ref = 20;//false，加入const之后变为只读，不可以修改
}

//使用场景：用来修饰形参，防止误操作
void showValue(int& val)//打印数据函数
{
	val = 1000;
	cout << "val = " << val << endl;
}
int main()
{
	int a = 100;
	showValue(a);
	cout << "a = " << a << endl;//此时a的值也被修改了
}

//使用场景：用来修饰形参，防止误操作
void showValue(const int& val)//打印数据函数
{
	//val = 1000;//此时不能修改数据了，一写就会报错
	cout << "val = " << val << endl;
}
int main()
{
	int a = 100;
	showValue(a);
	cout << "a = " << a << endl;//此时函数体不会通过修改形参从而修改实参了
}

三、函数提高

（1）函数默认参数

在c++中，函数的形参列表中的形参是可以有默认值的
语法：返回值类型函数名（参数 = 默认值）{ }

int func(int a, int b = 20 int c = 30)
{
	return a + b + c;
}
int main()
{
	cout << func(10) << endl;//此时不报错，正常输出60
	cout << func(10, 30) << endl;//此时得到的是70，说明如果我们自己传入数据，就用自己的数据，如果没有，那么用默认值

注意事项：
1、如果某个位置已经有了默认参数，那么从这个位置往后，从左到右必须有默认值
2、函数声明和函数实现只能有一个由默认参数

int func2(int a = 10, int b = 10);//函数声明
int func2(int a, intb)//函数实现，此时函数实现不能有默认参数
{	
	return a + b;
}

（2）函数占位参数

C++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置
语法：返回值类型函数名（数据类型）{ }

//占位参数， 在现阶段函数的占位参数存在意义不大，但是后面的课程中会用到
//占位参数，还可以有默认参数
void func(int a, int)
{
	cout << "this is func" << endl;
}
int main()
{
	func(10, 10);//占位参数必须填补，第二个值不传是不被允许的
}

//占位参数，还可以有默认参数
void func(int a, int = 10)
{
	cout << "this is func" << endl;
}
int main()
{
	func(10);//第二个值可以不传了
}

（3）函数重载

1. 函数重载概述

作用：函数名可以相同，提高复用性
函数重载满足条件：
1、同一个作用域下
2、函数名称相同
3、函数参数类型不同，或者个数不同，或者顺序不同
注意：函数的返回值不可以作为函数重载的条件

void func()
{
	cout << "func的调用" << endl;
}
void func(int a)
{
	cout << "func(int a)的调用" << endl;
}
void func(double a)
{
	cout << "func(int a)的调用" << endl;
}
int main()
{
	func();//调用的是第一个
	func(10);//调用的是第二个
	func(3.14);//调用的是第三个
}

void func()
{
	cout << "func的调用" << endl;
}
int func()//函数的返回值不可以作为函数重载的条件
{
	cout << "func(int a)的调用" << endl;
}
int main()
{
	func();//此时代码报错
}

2. 函数重载的注意事项

引用作为重载条件
函数重载碰到函数默认参数

//1、引用作为函数重载的条件
void fun(int& a)
{
	cout << "func(int& a)调用" << endl;
}
void fun(const int& a)//这属于类型不同的形参
{
	cout << "func(const int& a)调用" << endl;
}
int main()
{
	int a = 10;
	func(a);//此时调用的是第一个，因为a是一种变量，可以改变
	func(10);//此时就是调用第二个
	//假如是第一个，则会造成int& a = 10，这个是不合法的
	//但如果是第二个，const int& a = 10，这个是合法的

//1、函数重载碰到默认参数
void func2(int a, int b = 10)
{
	cout << "func2(int a, int b)的调用" << endl;
}
void func2(int a)
{
	cout << "func2(int a)的调用" << endl;
}
int main()
{
	//当函数重载碰到默认参数，出现二义性，报错，尽量避免这种情况
	func2(10);//此时代码报错，因为上下都能调用
	func2(10, 20);//此时可以运行

四、类与对象

C++面向对象的三大特性：封装、继承、多态
C++认为万事万物都皆为对象，对象上有其属性和行为

（1）封装

1.封装的意义

封装的意义：
1、将属性和行为作为一个整体，表现生活中的事务
2、将属性和行为加以权限控制
封装意义一：
在设计类的时候，属性和行为写在一起，表现事物

//设计一个圆类，求圆的周长
const double PI = 3.14;
//class 代表设计一个类，类后面紧跟着的就是类名称
class Circle
{
	//访问权限
	//公共权限
public:
	//类中的属性和行为，我们统称为成员
	//属性，也叫成员属性，成员变量
	int m_r;
	//行为，也叫成员函数，成员方法
	doubel calculateZC()
	{
		return 2 * PI * m_r;
	}
};
int main()
{
	//通过圆类，创建具体的圆（对象）
	//实例化（通过一个类 创建一个对象的过程）
	Circle c1;
	//给圆对象的属性进行赋值
	cl.m_r = 10;
	cout << "圆的周长为： " << cl.calculateZC() << endl;
}

封装意义二：
类在设计时，可以把属性和行为放在不同的权限下，加以控制
访问权限有三种：
1、public ---------公共权限，成员类内可以访问，类外可以访问
2、protected ----保护权限，成员类内可以访问，类外不可以访问
儿子也可以访问父亲中的保护内容
3、private---------私有权限，成员类内可以访问，类外不可以访问
儿子不可以访问父亲中的保护内容

2.struct和class的区别

在C++中struct和class唯一的区别就在于默认的访问权限不同
区别：
1、struct默认权限为公共
2、class默认权限为私有

class C1
{
	int m_A;//默认权限是私有，类外是私有
}
struct C2
{
	int m_A;//默认权限是公有
}

3.将成员属性设置为私有

优点1：将所有成员属性设置为私有，可以自己控制读写权限
优点2：对于写权限，我们可以检查数据的有效性

class Person
{
public:
	//设置姓名
	void setName(string name)
	{
		m_Name = name;
	}
	string getName()
	{
		return m_Name;
	}
	int getAge()
	{
		m_Age = 0;//初始化为0岁
		return m_Age;
	}
	void setAge(int age)
	{
		if(age < 0 || age > 150)
		{
			m_Age = 0;
			cout << "你这个老妖精！" << endl;
			return;//强制退出
		}
		m_Age = age;
	}
	void setLover(string lover)
	{
		m_Lover = lover;
	}
private:
	string m_Name;//可读可写
	int m_Age;//可读可写，如果想修改（年龄的范围必须是0~150之间）
	string m_Lover;//只写
}
int main()
{
	Person p;
	p.setName("张三");
	cout << "姓名为" << getName() << endl;
	cout << "年龄为" << getAge() << endl;

（2）对象的初始化和清理

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

1.构造函数和析构函数

对象的初始化和清理也是两个非常重要的安全问题
1、一个对象或者变量没有初始状态，对其使用后果是未知
2、同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题
C++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供
编译器提供的构造函数和析构函数是空实现
构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用
析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作
构造函数语法：类名( ) { }
1、构造函数，没有返回值也不写void
2、函数名称与类名相同
3、构造函数可以有参数，因此可以发生重载
4、程序在调用对象时候会自动调用构造，无需手动调用，而且只会调用一次
析构函数语法：~类名( ){ }
1、析构函数，没有返回值也不写void
2、函数名称与类名相同，在名称前加上符号~
3、析构函数不可以有参数，因此不可以发生重载
4、程序在对象销毁前会自动调用析构，无须手动调用，而且只会调用一次

class Person
{
Public:
	//1.构造函数
	//如果自己不写的话，编译器自动调用
	//编译器调用Person() { }空实现
	Person()
	{
		cout << "Person构造函数的调用" << endl;
	}
	//析构函数
	~Person()
	{
		cout << "Person的析构函数调用" << endl;
	}
}
//构造和析构都是必须有的实现，如果我们自己不提供，编译器会提供空实现
void test01()
{
	Person p;//在栈上的数据，test01执行完毕后，释放这个对象
}
int main()
{
	test01();//会自动调用Person()函数
	Person p;//此时只调用构造，这个对象不会被释放，除非程序结束，也就是在system("pause")这个语句结束后
	system("pause");
}

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

两种分类方式：
1、按参数分为：有参构造和无参构造（默认构造）
2、按类型分为：普通构造和拷贝构造

public:
	Person()
	{
		cout << "Person的无参构造函数调用" << endl;
	}
	Person(int a)
	{
		cout << "Person的有参构造函数调用" << endl;
	}

上面两种都是普通构造函数

Person(int a)
{
	age = a;
}
//拷贝构造函数
Person(const Person &p)
{
	//将传入的人身上的所有属性，拷贝到我身上
	age = p.age;
	cout << "Person的拷贝构造函数调用" << endl;
}

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

void test01()
{
	//1、括号法
	Person p;//默认构造函数调用
	Person p2(10);//有参构造函数
	Person p3(p2);//拷贝构造函数
	cout << "p2的年龄为：" << p2.age << endl;
	cout << "p3的年龄为：" << p3.age << endl;//此时p2，p3的年龄都是10
}

void test02()
{
	//2、显示法
	Person p1;
	Person p2 = Person(10);//有参构造，其中Person(10)是匿名对象
	Person p2 = Person(p3);//拷贝构造

在显示法中，Person(10)是匿名对象
特点：当前行执行结束后，系统会立即回收掉匿名对象

void test03()
{
	//3、隐式转换法
	Person p4 = 10;//相当于写了Person p4 = Person(10) 有参构造
	Person p5 = p4;//拷贝构造
}

注意事项：
1、调用默认构造函数的时候，不要加（）

void test02()
{
	Person p1();
}

因为上面这行代码，编译器会认为是一个函数的声明，不会认为在创建对象

2、不要利用拷贝构造函数，初始化匿名对象，编译器会认为Person(p3) == Person p3

void test02()
{
	Person(p3);
}

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

//1、使用一个已经创建完毕的对象来初始化一个新对象
void test01()
{
	Person p1(20);
	Person p2(p1);
}

//2、值传递的方式给函数参数传值
void doWork(Person p)
{
}
void test02()
{
	Person p;
	doWork(p);
}

个人理解：使用拷贝构造函数给函数参数传值，可以给函数传多个参数，但应该也是可以使用指针的。

这个是上面那个代码的运行结果

//3、值传递返回局部对象
Person doWork2()
{
	Person p1;
	cout << (int*)&p1 << endl;
	return p1;
}
void test03()
{
	Person p = doWork2();
	cout << (int*)&p1 << endl;
}

这个代码运行结果和上面那个一样
在这里插入图片描述
这个是上图的代码运行结果，可以看出，两个p1的位置不一样，不是同一个

4.构造函数调用规则

默认情况下，C++编译器至少给一个类添加3个函数
1.默认构造函数（无参，函数体为空）（空实现）
2.默认析构函数（无参，函数体为空）（空实现）
3.默认拷贝构造函数，对属性进行值拷贝（值拷贝）
构造函数调用规则如下：
1.如果用户定义有参构造函数，C++不再提供默认无参构造，但是会提供默认拷贝构造
2.如果用户定义拷贝构造函数，C++不会再提供其他构造函数

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;
};
void test01()
{
	Person p;
	p.m_age = 18;
	Person p2(p);
	cout << "p2的年纪为：" << p2.m_age << endl;
}	
int main()
{
	test 01();
}

在这里插入图片描述

此时就算把拷贝构造函数给注释掉，代码输出时候，p2的年纪依旧是18，因为编译器自行给我们进行了拷贝构造

5.深拷贝与浅拷贝

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

先上代码

#include <iostream>
using namespace std;

class Person
{
public:
	Person(int age, int height)
	{
		cout << "调用了有参构造函数" << endl;
		m_age = age;
		m_height = new int(height);
	}
	~Person()
	{
		//析构代码，将堆区开辟的数据做一个释放的操作
		if (m_height != NULL)
		{
			cout << "!" << endl;
			delete m_height;
			m_height = NULL;
		}
		cout << "调用了析构函数" << endl;
	}
	int m_age;
	int* m_height;

};

void test01()
{
	Person p1(18,180);
	cout << "年龄为" << p1.m_age << endl;
	cout << "身高为" << *p1.m_height << endl;
	Person p2(p1);
	cout << "年龄为" << p2.m_age << endl;
	cout << "身高为" << *p2.m_height << endl;
}
int main()
{
	test01();
}

其中，堆区的数据由程序员手动开辟，程序员也要手动释放，所以析构代码，将堆区开辟的数据做一个释放的操作。注意释放后，指针赋为NULL，防止产生空指针。

但是这段代码却报了错。

原因在于，如果利用编译器提供的拷贝构造函数，会做浅拷贝操作。在代码中，是先声明p1，然后p2，所以根据栈的先进后出，先释放p2。然后p2执行释放操作，释放了堆区，接着是p1执行操作，此时p1的m_height并不为空，所以也要执行释放堆区的操作，但是堆区已经被释放了，所以此时p1的释放堆区成了非法操作。故浅拷贝带来的问题就是堆区的内存重复释放。
在这里插入图片描述

//自己实现拷贝构造函数，解决浅拷贝带来的问题
Person(const Person &p)
{
	cout << "拷贝构造函数调用" << endl;
	m_Age = p.m_Age;
	//m_Heighr = p.m_Height;编译器默认实现就是这行代码
	//深拷贝操作
	m_Height = new int(*p.m_Height);
}

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

6.初始化列表

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

传统初始化操作

class Person
{
public:
	//传统初始化操作
	Person(int a, int b, intc)
	{
		m_A = a;
		m_B = b;
		m_C = c;
	}
	int m_A; 
	int m_B;
	int m_C;
}

初始化列表初始化属性（写死）

class Person
{
public:
	//传统初始化操作
	Person():m_A(10), m_B(20), m_C(30)
	{
	}
	int m_A; 
	int m_B;
	int m_C;
}
void test01()
{
	Person p;
	cout << "m_A = " << p.m_A << endl;
	cout << "m_B = " << p.m_B << endl;
	cout << "m_C = " << p.m_C << endl;
}

初始化列表初始化属性（不写死）

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(30, 20, 10);
	cout << "m_A = " << p.m_A << endl;
	cout << "m_B = " << p.m_B << endl;
	cout << "m_C = " << p.m_C << endl;
}

7.类对象作为类成员

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

例如：

class A{}
class B
{
	A a;
}

B类中有对象A作为成员，A为对象成员
那么当创建B对象时，A与B的构造和析构的顺序是谁先谁后？

class Phone
{
public:
	Phone(string pName)
	{
		m_PName = pName;
	}
	string m_PName;
};
class Person
{
public:
	// Phone m_Phone = pName 隐式转换法
	Person(string name, string pName):m_Name(name), m_Phone(pName)
	string m_Name;
	Phone m_Phone;
};
void test01()
{
	Person p("张三", "苹果");_
}

在上述代码中，会先构造Phone的构造函数，然后才是Person的构造函数
当其他类对象作为本类成员，构造时候先构造类对象，再构造自身，析构的顺序与构造相反，先析构自身，再析构类对象

8.静态成员

静态成员变量

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

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

class Person
{
public:
	static int m_A;
private:
	static int m_B;
};
int Person::m_A = 100;//Person作用域下的一个静态成员
int Person::m_B = 200;
这样就算类内做了声明，类外初始化
void test01()
{
	Person p;
	cout << p.m_A << endl;
	Person p2;
	p2.m_A = 200;
	cout << p.m_A << endl;
	此时，返回的数据还是200
}

由上述案例可以看出，静态成员变量，不属于某个对象上，所有对象都共享同一份数据。

因此静态成员变量由两种访问方式
1.通过对象进行访问
2.通过类名进行访问

void test02()
{
//通过类名进行访问
	cout << Person::m_A << endl;
}

静态成员变量也是有访问权限的，下面的代码就是错误的，类外访问不到私有静态成员变量

void test02()
{
//通过类名进行访问
	cout << Person::m_B << endl;
}

静态成员函数

静态成员函数的调用
1.通过对象访问
2.通过类名访问

而静态成员函数可以访问静态成员变量，静态成员函数不可以访问非静态成员变量

静态成员函数也是有访问权限的，类外访问不到私有静态成员函数

class Person
{
public：
	static void func()
	{
		m_A = 100;//静态成员函数可以访问静态成员变量
		//m_B = 200;//静态成员函数不可以访问非静态成员变量
		cout << "static void func调用" << endl;
	}
	static int m_A;
	int m_B;//非静态成员变量
};
int Person::m_A = 0;

通过对象访问
void test01()
{
	Person p;
	p.func();
}
通过类名访问
void test02()
{
	Person::func();
}

（3）C++对象模型和this指针

1.成员变量和成员函数分开存储

在C++中，类内的成员变量和成员函数分开存储，只有非静态成员变量才属于类的对象上面

class Person
{

};

void test01()
{
	Person p;
	cout << "size of p = " << siziof(p) << endl;
}

如果是空对象，占用内存空间为一个字节。C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置，每个空对象也应该有一个独一无二的内存地址

class Person
{
	int m_A;//非静态成员变量，属于类的对象上
	static int m_B;//静态成员变量，不属于类对象上
	void func(){}//非静态成员函数，不属于类对象上
	static void func2(){}//静态成员函数
};

void test01()
{
	Person p;
	cout << "size of p = " << siziof(p) << endl;
}

此时输出的size of p 是四个字节，而这四个字节，是int m_A的内存，int类型占四个字节，其他几个不属于类对象上。

2.this指针概念

通过4.3.1我们知道在C++中成员变量和成员函数是分开存储的，每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码，那么问题是：这一块代码是如何区分那个对象调用自己的呢？

C++通过提供特殊的对象指针，this指针，解决上述问题。this指针指向被调用的成员函数所属的对象

this指针是隐含每一个非静态成员函数内的一种指针
this指针不需要定义，直接使用即可

this指针的用途:

当形参和成员变量同名时，可用this指针来区分（解决名称冲突）
在类的非静态成员函数中返回对象本身，可使用return *this

class Person
{
public:
	Person(int age)
	{
		age = age;
	}
	int age;
}

void test01()
{
	Person p1(18);
	cout << "p1的年龄为：" << p1.age << endl;
}

此时代码运行结果为
p1的年龄为：-858993460
原因是因为上面三个age是同一个age，而不是Person类里面的age，所以值不发生变化

class Person
{
public:
	Person(int age)
	{
		this->age = age;
	}
	int age;
}

void test01()
{
	Person p1(18);
	cout << "p1的年龄为：" << p1.age << endl;
}

这样就正常输出18岁了，解决了名称冲突。
this指针指向被调用的成员函数所属的对象

class Person
{
public:
	Person(int age)
	{
		this->age = age;
	}
	void PersonAddAge(Person &p)
	{
		this->age += p.age;//自身的年龄，加上p的age
	}
	int age;
}

void test02()
{
	Person p1(10);
	Person p2(10);
	p2.PersonAddAge(p1);
	cout << "p2的年龄为：" << p2.age << endl;
}

class Person
{
public:
	Person(int age)
	{
		this->age = age;
	}
	Person& PersonAddAge(Person &p)
	{
		this->age += p.age;//自身的年龄，加上p的age
		
		return *this;
	}
	int age;
}

void test02()
{
	Person p1(10);
	Person p2(10);
	p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);
	cout << "p2的年龄为：" << p2.age << endl;
}

在PersonAddAge这个函数中，this指向p2的指针，而*this指向的就是p2这个对象本体。而如果你要返回p2的本体，就要用Person&，用引用的方式作为一个返回。

这个时候，代码输出结果就是40。

这种编程思想叫做链式编程思想。

而如果不采用引用的方式方式作为返回，而是使用了这样返回

Person PersonAddAge(Person &p)
	{
		this->age += p.age;//自身的年龄，加上p的age
		
		return *this;
	}

这个时候，代码输出结构就是20。原因是这样的，如果不使用引用的方式作为返回，在代码执行了一遍p2.PersonAddAge(p1)，拷贝构造出一个p2’来进行下一步p2’.PersonAddAge(p1)，接着执行完这句后，又拷贝构造出一个p2’‘来进行最后一步p2’'.PersonAddAge(p1)。

总之，如果采用值返回的方式，会重新创建一个p2，但如果采用引用的方式返回一个p2，则不会重新创建一个p2引用的本质是指针常量，用引用的方式返回代表着永远指向p2不会改变

3.空指针访问成员函数

C++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针

如果用到this指针，需要加以判断保证代码的健壮性

//空指针访问成员函数
class Person
{
public:
	void ShowClassName()
	{
		cout << "this is Person class" << endl;
	}
	void showPersonAge()
	{
		cout << "age = " << m_Age << endl;
	}
	int m_Age;
void test01()
{
	Person * p = NULL;
	p->showClassName();
	p->showPersonAge();
}

此时代码报错，报错原因在p->showPersonAge()这个语句，因为在cout << "age = " << m_Age << endl;这句里面，m_Age自动包含了this，也就是cout << "age = " << m_Age << endl;而用空指针调用的时候，调用的不是个确切的m_Age，而是个空的，所以报错了。

报错原因是因为传入的指针是为NULl

//空指针访问成员函数
class Person
{
public:
	void ShowClassName()
	{
		cout << "this is Person class" << endl;
	}
	void showPersonAge()
	{
		if(this == NULL)
		{
			return;
		}
		cout << "age = " << m_Age << endl;
	}
	int m_Age;
void test01()
{
	Person * p = NULL;
	p->showClassName();
	p->showPersonAge();
}

加上上述的if(this == NULL)，加强代码健壮性

4.const修饰成员函数

常函数：

成员函数后加const后我们称为这个函数为常函数
常函数内不可以修改成员属性
成员属性声明时加关键字mutable后，在常函数中依然可以修改

常对象：

声明对象前加const称该对象为常对象
常对象只能调用常函数

常函数

class Person
{
public:
	void showPerson() const
	{
		m_A = 100;
	}
	int m_A;
};

此时代码报错，报错原因：表达式必须是可修改的左值

其中void showPerson() const里面的m_A = 100，其实是this->m_A = 100;
this指针的本质是指针常量，指针的指向是不可以修改的 Person * const this
如果在void showPerson() const后面加上const，就相当于定义了const Person * const this，此时this指针指向的值也不能修改

在成员函数后面加const，修饰的是this指针指向，让指针指向的值也不可以修改

class Person
{
public:
	void showPerson() const
	{
		m_A = 100;
	}
	mutable int m_A;
};

此时的m_B为特殊变量，即使在常函数中，也可以修改这个值，加关键字mutable

常对象

class Person
{
public:
	void showPerson() const
	{
		m_A = 100;
	}
	int m_A;
	mutable int m_B;
};
void test01()
{
	const Person p;
	p.m_A - 100;
}

这段代码也报错。
在对象面前加const，变为常对象，但是修改为p.m_B = 100，代码不报错
所以m_B是特殊值，在常对象下也可以被修改。

常对象只能调用常函数，常对象不可以调用普通成员函数，因为普通成员函数可以修改属性