C++类与对象(四)友元&&内部类

目录

1.友元

  [1].友元函数

    (1)引入

    (2)特性与验证

    (3)总结

  [2].友元类

    (1)引入

    (2)特性与验证

    (3)总结

2.内部类

  [1]概念

  [2]特性与验证

  [3]总结

---

1.友元

  [1].友元函数

    (1)引入

        在C++中，因为需要保护类中成员的安全，许多成员都会设置为private权限，一般类中会提供公有方法去访问私有成员，但有时想要在类外直接访问私有成员，这就需要用到友元函数。

        例如在我的上一篇博客《C++实现日期类》中最后提到的重载 << 时所遇到问题，使用友元会简洁一些。

    (2)特性与验证

        <1>友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明并且加friend关键字。

        如何验证它不属于任何类？将它设置为private然后测试能否直接在类外调用。(本文代码均在win10系统vs2019下验证)

        代码一：可以在类外直接调用，特性验证。

//代码一
#include "iostream"
using namespace std;

class A {
private:
	friend void Print(A& a);
private:
	int _m;
	int _n;
public:
	A(int m = 10, int n = 1)
		:_m(m)
		, _n(n)
	{}
};

void Print(A& a) {
	cout << a._m << " " << a._n << endl;
}

int main() {
	A a(1, 2);
	Print(a);//输出 1 2
}

        <2>友元函数不能用const修饰。

        原因：在《C++类与对象(二) 六个默认成员函数》中曾提到过，const修饰成员函数的时候，就是修饰的其中的this指针。但是友元函数并不是类的成员函数，自然不可以用const修饰。

        <3>友元函数可以在类定义的任何地方声明，不受访问限定符限制。

        这一点在代码一中也看到了，就算设置为private，依然可以在类外直接调用。

        <4>友元函数的调用与普通函数的调用和原理相同。

        <5>一个函数可以是多个类的友元函数。

        举例：一个人可以有多个朋友。

    (3)总结

         <1>友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明并且加friend关键字。

        <2>友元函数不能用const修饰。

        <3>友元函数可以在类定义的任何地方声明，不受访问限定符限制。

        <4>友元函数的调用与普通函数的调用和原理相同。

        <5>一个函数可以是多个类的友元函数。

  [2].友元类

    (1)引入

        相比于上面的要使用一个函数访问一个类中的私有成员，还有一种情况是A类要访问B类中的所有成员，这个时候需要用到友元类。

    (2)特性与验证

        <1>友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类的非公有成员。

        代码二：

//代码二
#include "iostream"
using namespace std;

class A {
	friend class B;
private:
	int _m;
	int _n;
public:
	A(int m = 10, int n = 1)
		:_m(m)
		, _n(n)
	{}
};

class B {
public:
	void Print(A& a) {
		cout << a._m << endl;
	}
};

int main() {
	A a(1, 2);
	B b;
	b.Print(a);//输出 1
}

        <2>友元关系是单向的，不具有交换性。

        举例：小明把小王当朋友，允许让小王玩自己所有玩具，但小王不把小明当朋友，不让小明玩自己的玩具。

        <3>友元关系不能传递。

        举例：小明是小王的朋友，小张是小王的朋友，但小明和小王不认识，不是朋友。

    (3)总结

        <1>友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类的非公有成员。

        <2>友元关系是单向的，不具有交换性。

        <3>友元关系不能传递。

        <4>友元会破坏类的封装性。

2.内部类

  [1]概念

        概念：A类定义在B类的内部，A类就是内部类。内部类不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。

        注意：内部类就是外部类的友元类。

  [2]特性与验证

        <1>内部类可以定义在外部类的public、protected、private中都是可以的。

        <2>内部类可以直接访问外部类中的static、枚举成员、不需要外部类的对象名。

        代码三：如代码三，内部类中直接访问量外部类的static。

//代码三
#include "iostream"
using namespace std;

class A {
private:
	int _m;
	int _n;
	static int st;

public:
	A(int m = 10, int n = 1)
		:_m(m)
		, _n(n)
	{}

	class B {
	public:
		void BPrint() {
			cout << st << endl;
		}
	}; 

	void APrint() {
		B b;
		b.BPrint();
	}
};

int A::st = 10;

int main() {
	A a(1, 2);
	a.APrint();//输出 10
}

        <3>sizeof(外部类) == 外部类，和内部类没有关系。

        代码四：计算a对象大小时，结果为8，不清楚计算原理的，可以看我的《内存对齐与结构体大小》。

//代码四
#include "iostream"
using namespace std;

class A {
private:
	int _m;
	int _n;
public:
	A(int m = 10, int n = 1)
		:_m(m)
		, _n(n)
	{}

	class B {
		int a;
	}; 
};

int main() {
	A a(1, 2);
	cout << sizeof(a) << endl;//输出 8
}

  [3]总结

        <1>内部类可以定义在外部类的public、protected、private中都是可以的。

        <2>内部类可以直接访问外部类中的static、枚举成员、不需要外部类的对象名。

        <3>sizeof(外部类) == 外部类，和内部类没有关系。