类和对象（五）

在 C++ 的面向对象编程中，封装是三大特性之一，它通过访问限定符（public、protected、private）来控制类成员的可见性，从而保护数据安全。然而，在某些场景下，我们需要让特定的函数或类能够访问类的私有成员，这时 C++ 提供了 friend（友元）机制来打破封装的限制。此外，类的嵌套定义（内部类）和匿名对象也是 C++ 中常见且实用的语法特性。本文将围绕友元、内部类和匿名对象三个主题展开，通过代码示例帮助读者理解它们的用法、特点与注意事项。

友元

对于一个类来说，成员访问限定符可以很好地保护类中某些成员不被外部访问，但存在一个特殊的关键字 friend。它放在函数或类的前面，用来声明该函数或类是该类的友元函数或友元类。

cpp 复制代码

class A
{
	//类B是类A的友元类
	friend class B;
	//友元函数
	friend void Swap(A& a);
public:
	A(int a1 = 1, int a2 = 1)
		:_a1(a1)
		, _a2(a2)
	{
		;
	}
private:
	int _a1;
	int _a2;
};

该友元函数和友元类可以无视成员访问限定符，直接访问该类的所有成员。

cpp 复制代码

void Swap(A& a)
{
	int tmp = a._a1;
	a._a1 = a._a2;
	a._a2 = tmp;
}

class B
{
public:
	B(A& a)
		:_b1(a._a1)
		,_b2(a._a2)
	{
		;
	}
private:
	int _b1;
	int _b2;
};

就像朋友一样，声明 Swap 函数和类 B 是类 A 的朋友，它们就可以访问类 A 的所有成员了。

这是一种单向关系，类A的友元是类B，类B可以直接访问类A的所有成员，但类A不能直接访问类B中的所有成员。
此外友元也不具有传递性，类A的友元是类B，类B的友元是类C，但不能说类A的友元是类C。
友元的使用会破坏类封装性，增强耦合度，所以尽量少用。

内部类

内部类就是在类中封装一个类，它具有以下特点：

内部类和外部类是两个独立的类，互不干扰，也不影响各自类大小。
内部类默认为外部类的友元类。
内部类受到外部类的访问限定符限制。

比如我在类A内封装一个类B。

cpp 复制代码

class A
{
	friend void Swap(A& a);
public:
	A(int a1 = 1, int a2 = 1)
		:_a1(a1)
		, _a2(a2)
	{
		;
	}
	//内部类
	class B
	{
	public:
		B(A& a)
			:_b1(a._a1)
			,_b2(a._a2)
		{
			;
		}
	private:
		int _b1;
		int _b2;
	};
private:
	int _a1;
	int _a2;
};

受到 public 限定符影响，类 B 可以被外部访问，但需要通过类域查找。

cpp 复制代码

	A::B b1(A a1);//实例化类B对象

也可以将类B限定为类A的专有类。

匿名对象

我们可以通过类来实例化出对象，此外还有一种实例化，实例化出的是匿名对象，它的使用如下：

cpp 复制代码

class A
{
public:
	A(int a1 = 1, int a2 = 2)
		:_a1(a1)
		, _a2(a2)
	{
		;
	}
private:
	int _a1;
	int _a2;
};

int main()
{
	A a;//实例化对象

	A();//匿名对象
	A(10, 20);//匿名对象
	return 0;
}

匿名对象的生命周期只到当前行为止。