开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> C++知识库 -> C++核心入门-04类和对象-（3）C++对象模型、this指针和友元 -> 正文阅读

[C++知识库]C++核心入门-04类和对象-（3）C++对象模型、this指针和友元

4.3 C++对象模型和类型指针

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

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

（1）空对象占用内存——占用1个字节空间
例子：

#include<iostream>
using namespace std;

//成员变量 和 成员函数 分开存储的
class Person
{

};


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

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

运行结果：
在这里插入图片描述
C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置。每个空对象也应该有一个独一无二的内存地址。

（2）非静态成员变量——在类的对象上

class Person
{
	int m_A;//非静态成员变量  属于类的对象上

};

运行结果：
在这里插入图片描述

（3）静态成员变量、静态成员函数和非静态成员函数——都不在类的对象上

class Person
{
	int m_A;//非静态成员变量  属于类的对象上

	static int m_B;//静态成员变量 不属于类的对象上

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

	}

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

	}
};

int Person::m_B = 1;

在这里插入图片描述
总结：

空对象占用一个字节内存；
只有非静态成员变量在类的对象上。

4.3.2 this指针概念

通过上一小节，我们知道C++中，成员变量和成员函数是分开存储的。

每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码，那么问题是：这一块代码是如何区分是哪个对象调用自己呢？

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

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

this指针的用途：

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

（1）解决名称冲突

例子：

#include<iostream>
using namespace std;

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

	int age;
};
//1、解决名称冲突
void test01()
{
	Person p1(18);
	cout << "p1的年龄为：" << p1.age << endl;
}


int main()
{
	test01();

	system("pause");
	return 0;
}

运行结果：
在这里插入图片描述
很明显，这里出现错误了。

可以看到，当选中成员函数中形参的age时，
在这里插入图片描述

解决方法：
1）将成员变量改名，不要和形参重复；
2）使用this指针。

class Person
{
public:
	Person(int age)
	{
		//this指针指向被调用的成员函数所属的对象
		this->age = age;
	}

	int age;
};

在这里插入图片描述
（2）返回对象本身用this

#include<iostream>
using namespace std;

class Person
{
public:
	Person(int age)
	{
		//this指针指向被调用的成员函数所属的对象
		this->age = age;
	}

	Person& PersonAddAge(Person &p)
	{
		this->age += p.age;
		//this指向的是p2的指针，而*this指向的就是p2这个对象本体
		return *this;
	}

	int age;
};
//1、解决名称冲突
void test01()
{
	Person p1(18);
	cout << "p1的年龄为：" << p1.age << endl;
}

//2、返回对象本身用 *this
void test02()
{
	Person p1(10);
	Person p2(10);

	//链式编程思想
	p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);

	cout << "p2的年龄为：" << p2.age << endl;
}
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

在这里插入图片描述

4.3.3 空指针访问成员函数

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

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

例子：

#include<iostream>
using namespace std;

//空指针访问成员函数
class Person
{
public:

	void showPersonAge()
	{
		//报错的原因是因为传入的指针为NULL
		cout << "age=" << m_Age << endl;
	}

	int m_Age;
};

void tes01()
{
	Person * p = NULL;

	p->showPersonAge();
}
int main()
{
	tes01();
	system("pause");
	return 0;
}

运行结果：
在这里插入图片描述
因为成员函数中，属性前面都默认加了 this->
所以，这里就是相当于：cout<<“age=” << this->m_Age << endl;
又因为传入的是空指针，所以：cout<<“age=” << NULL->m_Age << endl;

改进方法，就是加入一句判断:

	void showPersonAge()
	{
		//报错的原因是因为传入的指针为NULL
		if (this==NULL)
		{
			return;
		}
		cout << "age=" << m_Age << endl;
	}

4.3.4 const修饰成员函数

常函数：

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

常对象：

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

#include<iostream>
using namespace std;

//常函数
class Person
{
public:

	//this指针的本质是 指针常量  指针的指向是不可以修改的
	//const Person * const this;
	//在成员函数后面加const，修饰的是this的指向，让指针指向的值也不可以进行修改
	void showPerson() const
	{
		this->m_B = 100;
		//this->m_A = 40;
		//this = NULL;//this指针不可以修改指针的指向

	}

	void func()
	{
		m_A = 100;
	}

	int m_A;
	mutable int m_B;//特殊变量，即使在常函数中，也可以修改这个值，加关键字mutable
};

void test01()
{
	Person p;
	p.showPerson();
}

//常对象
void test02()
{
	const Person p;//在对象前加const，变为常对象
	//p.m_A = 10;
	p.m_B = 100;//m_B是特殊值，在常对象下可以进行修改

	//常对象只能调用常函数
	p.showPerson();
	//p.func();  常对象不可以调用普通成员函数，因为普通成员函数可以修改属性
}
int main()
{
	system("pause");
	return 0;
}

总结：
（1）this指针的本质是 指针常量 指针的指向是不可以修改的，
在成员函数后面加const，修饰的是this的指向，让指针指向的值也不可以进行修改
const Person * const this;
（2）加关键字mutable，即使在常函数中，也可以修改这个值。
（3）在对象前加const，变为常对象;m_B是特殊值，在常对象下可以进行修改；常对象只能调用常函数；常对象不可以调用普通成员函数，因为在普通成员函数中可以修改属性

4.4 友元

案例：
在生活当中，你的家里有客厅（Public)，有你的卧室（Private)
客厅是所有的客人都可以进来，但是你的卧室是私有的，也就是说只有你能进去（或者说，你可以允许你的好基友进去）

在程序当中，有些私有属性也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术。

友元的目的就是让一个函数或者类访问另一个类中的私有成员。

友元的关键词为：friend

友元的三种实现：

全局函数做友元；
类做友元；
成员函数做友元

4.4.1 全局函数做友元

示例：

#include<iostream>
#include<string>
using namespace std;

//建筑物类
class Building
{
public:
	Building()//构造函数，要和类名相同
	{
		m_SittingRoom = "客厅";
		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 building;
	GoodGay(&building);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

在这里插入图片描述

创造一个Building类，里面设有公共属性 m_SittingRoom 和私有属性 m_BedRoom；在类外创建了一个全局函数GoodGay（），用于访问类中的属性。
可以看到，在访问私有属性m_BedRoom时，出现了报错。

解决办法：

	//全局函数GoodGay是Building的好朋友，可以访问私有的卧室
	friend void GoodGay(Building *building);

在类内，利用friend关键词，对全局函数进行声明，让其成为友元
在这里插入图片描述
完整示例代码：

#include<iostream>
#include<string>
using namespace std;

//建筑物类
class Building
{
	//全局函数GoodGay是Building的好朋友，可以访问私有的卧室
	friend void GoodGay(Building *building);
public:
	Building()//构造函数，要和类名相同
	{
		m_SittingRoom = "客厅";
		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 building;
	GoodGay(&building);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

运行结果：
在这里插入图片描述

4.4.2 类做友元

完整示例代码：

#include<iostream>
#include<string>
using namespace std;

class Building;
class GoodGay
{
public:
	GoodGay();
public:
	void visit();//参观函数 访问Building中的属性
	Building *building;
};

class Building
{
	//GoodGay是本类的好朋友，可以访问本类中私有的成员
	friend class GoodGay;
public:
	Building();
public:
	string m_SittingRoom;//客厅
private:
	string m_BedRoom;//卧室
};

//类外写成员函数
Building::Building()
{
	m_SittingRoom = "客厅";
	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();
	system("pause");
	return 0;
}

我的理解：
这里创建了两个类：GoodGay和Building
在这里插入图片描述
在GoodGay类中，第12行创建了一个Building类的指针，由于之前没有定义Building类，所以在第5行事先对Building类做了声明，否则会报错。

在第18行，由于待会GoodGay类会访问到Building类中的私有属性，所以这里进行了将GoodGay变为友元的操作。

在这两个类中，都只是对成员函数进行了声明，并没有进行详细的写，是准备在类外进行成员函数的书写。

在这里插入图片描述
可以看到，在类外写成员函数，需要在函数前面加上类名以及：：，代表处于该类的域下。

第37行，利用new关键字这个，我没有看懂。。。。。。。。。。。。。。。

总的来说，将类作为友元，就是利用关键字friend，在需要被访问的那个类里面进行声明即可。

代码运行结果：
在这里插入图片描述

4.4.3 成员函数做友元

完整示例代码：

#include<iostream>
#include<string>
using namespace std;

class Building;
class GoodGay
{
public:
	GoodGay();
	void visit();//让visit函数可以访问Building中的私有成员
	void visit2();//让visit2函数不可以访问Building中的私有成员

	Building * building;
};

class Building
{
	//告诉编译器 GoodGay类下的visit成员函数作为本类的好朋友，可以访问私有属性
	friend void GoodGay::visit();
public:
	Building();
public:
	string m_SittingRoom;//客厅

private:
	string m_BedRoom;//卧室
};

//类外实现成员函数
Building::Building()
{
	m_SittingRoom = "客厅";
	m_BedRoom = "卧室";
}
GoodGay::GoodGay()
{
	building = new Building;
}

void GoodGay::visit()
{
	cout << "visit函数正在访问：" << building->m_SittingRoom << endl;
	cout << "visit函数正在访问：" << building->m_BedRoom << endl;
}
void GoodGay::visit2()
{
	cout << "visit2函数正在访问：" << building->m_SittingRoom << endl;
	//cout << "visit2函数正在访问：" << building->m_BedRoom << endl;
}

void test01()
{
	GoodGay gg;
	gg.visit();
	gg.visit2();
}
int main()
{
	test01();
	system("pause");
	return 0;
}

在这里插入图片描述
这一节的关键性代码就是第19行。
GoodGay类中的visit()和visit2(）函数，都要访问Buidling类中的属性。对于公共属性m_SittingRoom，两个函数都可以访问；对于私有属性m_BedRoom，由于在Buiding类中，第19行对成员函数visit（）进行了变为友元的操作，所以：visit()函数可以访问m_BedRoom，visit2()不可以访问。