C++学习笔记12，C++核心编程

C++对象模型和this指针

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

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

class Person8
{
	int p_age;			//非静态成员变量	属于类的对象上	
	static int p_tell;	//静态成员变量		不属于类的对象上

	void AAA()			//非静态成员函数	不属于类的对象上
	{

	}
	static void BBB()	//静态成员函数		不属于类的对象上
	{

	}
};
int Person8::p_tell = 0;
void test19()
{
	Person8 p1;
	cout << "size of p1 = " << sizeof(p1) << endl;
	//空对象占有内存空间为：1
	//C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置，每个空对象也应该有一个独一无二的内存地址
}
int main27()
{
	test19();

	system("pause");
	return 0;
}

2、this指针概念

C++中，成员函数和成员变量分开存储，每个非静态成员函数只会诞生一份函数实例，即：多个同类型的对象会共用一块代码，代码块如何区分是哪个对象调用自己？ 用this指针区分

this指针 ：指向被调用的成员函数所属的对象 ！！！

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

用途：

1. 当形参和成员变量同名时，可以用this指针来区分
2. 在类的非静态成员函数中返回对象本身，可使用 return *this;

class Person9
{
public:
	//int p_age;
	int age;

	Person9(int age)//有参构造函数
	{
		//p_age = age;
		//age = age;	//系统会认为函数内的3个age是同一个变量，不会改变属性age
		
		//1、解决名称冲突
		this->age = age;	//this指向被调用的成员函数（Person9(int age)）所属的对象（p1）
	}

	void AddPersonAge(Person9 &p)
	{
		this->age += p.age;
	}

	Person9& AddPersonAge2(Person9 &p)//返回值类型加 &，如果不加&按值传递，根据前面所学，编译器会拷贝一份p为p'，返回
	{
		this->age += p.age;

		//2、返回对象本身用return *this
		return *this;	//this是指向p2的指针，则*this就是指向p2这个对象本体
	}
};
void test21()
{
	Person9 p1(18);
	cout << "p1的年龄是：" << p1.age << endl;

	Person9 p2(18);
	p2.AddPersonAge(p1);
	cout << "p2的年龄是：" << p2.age << endl;

	//如果想多加几次年龄
	//p2.AddPersonAge(p1).AddPersonAge(p1).AddPersonAge(p1);
	p2.AddPersonAge2(p1).AddPersonAge2(p1).AddPersonAge2(p1);	//链式编程思想
	cout << "p2的年龄是：" << p2.age << endl;
}
int main28()
{
	test21();

	system("pause");
	return 0;
}

3、空指针访问成员函数

//C++中，空指针也可以调用成员函数，但是要注意有没有用到this指针，如果用到this指针，需要加以判断，保证代码健壮性

class Person10
{
public:
	int p_age;

	void ShowClassName()
	{
		cout << "this is ShowClassName()" << endl;
	}
	void ShowPersonAge()
	{
		if (this == NULL)
		{
			return;
		}

		cout << "the person age is " << this->p_age << endl;//在属性前默认都有this（this->p_age）	this指向*p1，p1是一个空指针，访问其属性p_age，“无中生有”，所以要在前边加一个if语句保证健壮性
	}
};
void test22()
{
	Person10 *p1 = NULL;

	p1->ShowClassName();
	p1->ShowPersonAge();
}
int main29()
{
	test22();

	system("pause");
	return 0;
}

4、const修饰成员函数（const限制只读状态）

常函数：
	成员函数后加const后，称该函数为常函数
	常函数内不可以修改成员属性
	成员属性声明时加关键字mutable后，在常函数中依然可以修改
常对象：
	声明对象前加const，称该对象为常对象
	常对象只能调用常函数

class Person11
{
public:
	int p_age;
	mutable int p_id;//特殊的变量，即使在常函数中，也可以修改这个值	mutable

	//常函数
	//this指针的本质 是指针常量，指针的指向是不可以修改的	Person11 * const this;
	void ShowPerson()const//相当于 const Person11 * const this; 修饰的是this的指针，使指针指向的值也不能修改
	{
		//p_age = 18;//相当于 this->p_age = 18;	（每个成员函数内部都有一个this指针）
		//this = NULL;//this指针已经指向p1，不能再修改指向

		p_id = 10001;
	}

	void test()
	{

	}
};
void test23()
{
	Person11 p1;
	p1.ShowPerson();
}
//常对象
void test23_2()
{
	const Person11 p2;
	//p2.p_age = 20;	//常对象不能修改成员属性
	p2.p_id = 10002;	//特殊的变量，在常对象下也可以修改

	p2.ShowPerson();//常对象只能调用常函数
	//p2.test();	//常对象不能调用普通成员函数，因为普通成员函数可以修改属性
}

（哔哩哔 哩黑马程序员 C++教程 学习笔记，如有侵权请联系删除）