【C++】学习笔记[九]

一、C++对象模型和this指针

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

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

对象所占用内存大小：

#include <iostream>
using namespace std;

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

class Person
{

};

void test01()
{
	Person p;

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

int main()
{
	test01();
	return 0;
}

静态成员变量，静态成员函数和普通成员函数都不属于类的对象上

举例如下：

#include <iostream>
using namespace std;

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

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

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

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

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

};

int Person::m_B = 4;

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

int main()
{
	test01();
	return 0;
}

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

this指针

• C++通过提供特殊的对象指针，this指针指向被调用的成员函数所属的对象
• this指针是隐含每一个非静态成员函数内的一种指针
• this指针不需要定义，直接使用即可

this指针的用途：

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

练习代码如下：

#include <iostream>
using namespace std;


//解决名称冲突问题
//this指针指向被调用的成员函数所属的对象
class Person
{
public:

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

};

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

int main()
{
	test01();
	return 0;
}

二、空指针访问成员函数

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

练习代码如下：

#include <iostream>
using namespace std;

//空指针调用成员函数
class Person
{
public:

	void showClassName()
	{
		cout << "this is person class" << endl;
	}

	void showPersonAge()
	{
		if (this == NULL)//解决30行的问题
		{
			return;
		}
		cout << "age = " << m_Age << endl;
	}

	int m_Age;
};

void test01()
{
	Person* p = NULL;
	p->showClassName();//true,程序不会崩溃
	p->showPersonAge();//error 程序崩溃，空指针不能访问成员变量
}

int main()
{
	test01();
	return 0;
}

三、const修饰成员函数

常函数：

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

常对象：

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

练习代码如下：

#include <iostream>
using namespace std;

class Person
{
public:
	//在成员函数后面加const，修饰的是this指针，让指针指向的值也不可以改变
	void showPerson() const
	{
		//m_A = 100;//不可修改
		m_B = 100;//可修改
	}

	void func()
	{

	}

	int m_A;
	mutable int m_B;//
};

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

void test02()
{
	//在对象前加const，变成常对象
	const Person p;
	//p.m_A = 100;//不可修改
	p.m_B = 100;//可修改

	//p.func();//常对象只能调用常函数
}

int main()
{
	test01();
	test02();
	return 0;
}

四、友元

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

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

友元的关键字为friend

友元的三种实现：

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

（一）全局函数做友元

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


//设计一个建筑物的类
class Building
{
	//goodGay全局函数是Building这个类的好朋友，可以随时访问该类中的私有成员
	friend void goodGay(Building* building);
public:

	Building()
	{
		m_SittingRoom = "客厅";
		m_BedRoom = "卧室";
	}
	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();
	return 0;
}

（二）类做友元

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

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

};
class GoodGay
{
public:
	GoodGay()
	{
		//创建一个建筑物的对象
		building = new Building;
	}
	void visit()//参观函数访问Building中的公有和私有属性
	{
		cout << "好基友正在访问：" << building->m_SittingRoom << endl;
		cout << "好基友正在访问：" << building->m_BedRoom << endl;
	}
	Building* building;
};

void test01()
{
	GoodGay gg;
	gg.visit();
}

int main()
{
	test01();
	return 0;
}

（三）成员函数做友元

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

class Building;
class GoodGay
{
public:
	GoodGay();

	void visit();//让visit函数可以访问Building中私有成员
	void visit2();//让visit2函数不可以访问Building中私有成员

	Building* building;
};
class Building
{
	//告诉编译器 goodGay作用域下的visit函数是Building类的好朋友，可以访问到Building类中私有内容
	friend void GoodGay::visit();
public:

	Building();
public:

	string m_SittingRoom;//客厅

private:

	string m_BedRoom;//卧室

};

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

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

void test01()//测试函数
{
	GoodGay g;
	g.visit();
	g.visit2();
}
int main() {

	test01();
	return 0;
}

✨✨✨
特意为1024而来🤣