【c++】cpp对象类型和this指针，友元

4.3 cpp对象模型和this指针

4.3.1成员变量和成员函数分开存储

在cpp中，类内成员变量和成员函数分开存储

只有非静态成员变量才属于类的对象上

#include <bits/stdc++.h>
using namespace std;
class Person
{
public:
	int mA = 0;//非静态成员变量占对象空间
	static int mB;//静态成员变量不占对象空间
public:
	void func()//函数不占用对象空间，所有函数共享一个函数
	{
		cout << "mA:" << this->mA << endl;
	}
	//静态成员函数也不占对象空间
	static void sfunc() {}
};
int main()
{
	//一个“空”对象占用一个字节,一个int 变量占四个字节
	cout << sizeof(Person) << endl;
	return 0;
}

4.3.2 this 指针概念

每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会公用一块代码

那么问题是：这一块代码是如何区分哪个对象调用自己的呢？

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

this指针是隐含每一个非静态成员函数内的一种指针

this指针不需要定义，直接使用即可

this指针的用途：

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

#include <bits/stdc++.h>
using namespace std;
class Person
{
public:
	Person(int age)
	{
		//当形参和成员变量同名时，可用this指针来区分
		this->age = age;
	}
	Person& PersonAddPerson(Person p)
	{
		this->age += p.age;
		return *this;//返回对象本身
	}
	int age;
};
void test01()
{
	Person p1(10);
	cout << "p1.age = " << p1.age << endl;
	Person p2(10);
	p2.PersonAddPerson(p1).PersonAddPerson(p1).PersonAddPerson(p1);
	cout << "p2.age = " << p2.age << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

4.3.3空指针访问成员函数

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

示例:

#include <bits/stdc++.h>
using namespace std;
class Person
{
public:
	void ShowClassName()
	{
		cout << "我是Person类" << endl;
	}
	void ShowPerson()
	{
		if (this == NULL)
			return;
		cout << mAge << endl;
	}
public: 
int mAge;
};
void test01()
{
	Person* p = NULL;
	p->ShowClassName();//空指针，可以调用成员函数
	p->ShowPerson();//但是如果成员函数中使用了this指针，就不可以了
}
int main()
{
	test01();
	return 0;
}

4.3.4 const 修饰成员函数

常函数

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

常对象

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

#include <bits/stdc++.h>
using namespace std;
class Person
{
public:
	int m_A;
	mutable int m_B;//相当于钥匙,可以修改
public:
	Person()
	{
		m_A = 0;
		m_B = 0;
	}
	//this指针的本质是一个指针常量，指针的指向不可修改
	//如果想让指针指向的值也不可以修改，需要声明常函数
	void ShowPerson()const
	{
		//const Type* const pointer;
		//this = NULL;//不能修改指针的指向 Person *const this;
		//this->m_A=100;//但this指向的对象的数据是可以改变的
		//const 修饰成员函数，表示指针指向的内存空间的数据不能修改，除了mutable
		this->m_B = 100;
	}
	void MyFunc()const
	{
		//m_A = 10000;
	}
};
void test01()
{
	const Person person;//常量对象
	cout << person.m_A << endl;//常对象成员变量的值可以访问，但是不可以改变
	person.m_B = 10;//但是常对象可以修改mutable修饰的成员变量的值
	person.MyFunc();//常对象只能调用常函数
}
int main()
{
	test01();
	return 0;
}

4.4 友元

生活中你的家中有客厅（Public），有你的卧室（Private）客厅所有来的客人都可以进去，但是你的卧室是私有的，也就是说只有你能进去，但是，你也可以允许你的好闺蜜好基友进去。

在程序里，这些私有属性 也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术，友元的目的就是让一个函数或者类访问另一个类中的私有成员

关键字friend

友元的三种表现

1. 全局函数做友元
2. 类做友元
3. 成员函数做友元

4.4.1 全局函数做友元

#include <bits/stdc++.h>
using namespace std;
class Building
{
	//告诉编译器 goodGay全局函数是Buliding类的好朋友，可以访问类中的私有内容
	friend void goodGay(Building &building);
public:
	Building()
	{
		this->m_SittingRoom = "客厅";
		this->m_BedRoom = "卧室";
	}
public:
	string m_SittingRoom;
private:
	string m_BedRoom;
};
void goodGay(Building &building)
{
	cout << "好基友正在访问：" << building.m_SittingRoom << endl;
	cout << "好基友正在访问：" << building.m_BedRoom << endl;
}
void test01()
{
	Building b;
	goodGay(b);
}
int main()
{
	test01();
	return 0;
}

4.4.2 类做友元

#include <bits/stdc++.h>
using namespace std;
class Building;//这里要提前声明
class goodGay
{
public:
	goodGay();
	void visit();
private:
	Building *building;
};
class Building
{
	//告诉编译器 goodGay类是Building类的好朋友，可以访问到Building类中私有内容
	friend class goodGay;
public:
	Building();
public:
	string m_SittingRoom;
private:
	string m_BedRoom;
};
Building::Building()
{
	this->m_SittingRoom = "客厅";
	this->m_BedRoom = "卧室";
}
goodGay::goodGay()
{
	building = new Building;//创建建筑物对象
}
void goodGay::visit()
{
	cout << "好基友正在访问" << building->m_SittingRoom << endl;
	cout << "好基友正在访问" << building->m_BedRoom << endl;
}
void test01()
{
	goodGay gg;
	gg.visit();
}
int main()
{
	test01();
	return 0;
}

4.4.3成员函数做友元

#include <bits/stdc++.h>
using namespace std;
class Building;
class goodGay
{
public:
	goodGay();
	void visit();//只让visit函数作为Building的好朋友，可以发访问Building中私有内容
	void visit2();
private:
	Building* building;
};
class Building
{
	friend void goodGay::visit();
public:
	Building();
public:
	string m_SittingRoom;//卧室
private:
	string m_BedRoom;//客厅
};
Building::Building()
{
	this->m_SittingRoom = "客厅";
	this->m_BedRoom = "卧室";
}
goodGay::goodGay()
{
	building = new Building;
}
void goodGay::visit()
{
	cout << "好基友正在访问" << building->m_SittingRoom << endl;
	cout << "好基友正在访问" << building->m_BedRoom << endl;
}
void goodGay::visit2()
{
	cout << "好基友正在访问" << building->m_SittingRoom << endl;
	//cout << "好基友正在访问" << building->m_BedRoom << endl;//不可访问
}
void test01()
{
	goodGay gg;
	gg.visit();
}
int main()
{
	test01();
	return 0;
}