友元类与嵌套类

友元类

可以通过friend关键字声明一个函数为某个类的友元函数,友元函数可以访问该类中的所有成员

class T
{
	int hp; int mp;//没有说明默认私有private
	void GetHp()
	{
		std::cout << hp;
	}
	friend void SetHp(T& t1);
 };

void SetHp1(T& t1)
{
	t1.hp = 2500;//报错，私有成员变量不可访问
}

void SetHp(T& t1)
{
	t1.hp = 2500;//可以访问私有变量
	t1.GetHp();
}

int main()
{
	
}
class T2;//要先声明一下T2
class T1
{
	int hp; int mp;//没有说明默认私有private
	void GetHp()
	{
		std::cout << hp;
	}
	friend void SetHp(T1& t1,T2& t2);//不然编译器在这里不知道T2
 };

class T2
{
	int hp; int mp;//没有说明默认私有private
	void GetHp()
	{
		std::cout << hp;
	}
	friend void SetHp(T1& t1, T2& t2);
};

void SetHp(T1& t1,T2& t2)
{
	t1.hp = 2500;
	t1.GetHp();
}

int main()
{
	
}

SetHp()并非T1、T2的成员函数
class T2;
class T1
{
	int hp; int mp;//没有说明默认私有private
	void GetHp()
	{
		T2 t;
		t.GetHp();//报错，不可访问
		std::cout << hp;
	}
	friend class T2;//T2就可以访问T1的私有成员变量，但T1不可以访问T2的私有变量
	friend void SetHp(T1& t1,T2& t2);
 };

class T2
{
	int hp; int mp;//没有说明默认私有private
	void GetHp()
	{
		T1 t;
		t.GetHp();//正确
		std::cout << hp;
	}
	friend void SetHp(T1& t1, T2& t2);
};

友元会破坏类的封装性,所以建议仅仅是在没有更好的选择的情况下使用友元

友元类不是一种平等的关系

嵌套类

我们可以在类的声明中再声明一个类，在类中声明的类称为嵌套类，而声明嵌套类的类称为外层类

作用域

嵌套类的声明在外层类中,因此嵌套类的作用域受外层类限定

假如要在类外声明一个Weapon对象

Role:: Weapon mWpon;

嵌套类的作用域受封装属性管辖, 即private封装的嵌套类是无法在类外使用的

enum class WeaponLv
{
	normal=0,
	high,
	rare,
	myth
};

class Role   //外层类
{
public:
	class Weapon   //嵌套类
	{
		short lv;
		WeaponLv wlv;
	};
	int hp;
	int mp;
	Weapon lsfthands;
};
int main()
{
	Role r1;
	Weapon wpl;//错误，因为Weapon的作用域是Role
	Role::Weapon wpl;//正确,注意Weapon要放在public下
}

在类外定义嵌套类

• 在类外定义嵌套类

class Role   //外层类
{
public:
	class Weapon;  //在Role里声明一下Weapon
	int hp;
	int mp;
};
class Role::Weapon  //在外面定义Weapon
{
	Weapon* ReturnW();
public:
	Weapon();//构造函数
	short lv;
};

Role::Weapon::Weapon()
{
	std::cout << "Weapon!" << std::endl;
}

Weapon* Role::Weapon::ReturnW();//错误，因为Weapon*也需要Role::
{}

Role::Weapon* Role::Weapon::ReturnW()//正确
{}

int main()
{
	Role r1;
	Role::Weapon wpl;
}

class Role   //外层类
{
public:
	class Weapon;  //在Role里声明一下Weapon
	int hp;
	int mp;
	Weapon lefthands;//错误（不允许使用不完整的类型），因为Weapon只进行了声明
};
class Role::Weapon  //在外面定义Weapon
{
public:
	Weapon();
	short lv;
};
——————————————————————————————————————————————————————————————————————————————————————
class Role   //外层类
{
public:
	class Weapon  
	{
	public:
		short lv;
		WeaponLv wlv;
	};
	int hp;
	int mp;
	Weapon lefthands;//正确
};

嵌套类和外层类的访问权限：

● 嵌套类可以访问外层类的所有（静态）成员

● 外层类仅能访问嵌套类的公有成员

局部类

定义在函数内的类称为局部类

作用域：该函数内

• 局部类的定义必须写在类内（原因：在函数内不能声明另一个函数）

• 局部类中不允许使用静态成员变量

• 局部类可以访问全局变量