C++ 基础【09】

本文代码仓库地址： gitee码云CSDN笔记仓库地址

---

---

全局函数做友元【Class11】

// 友元 -- 全局函数做友元
#include <iostream>

using namespace std;


class person01_xy {
	// 加上这句话我就把 全局函数fun01 当成朋友了，既然是朋友那他可以访问我私有的成员
	friend void fun01();

public:
	void mFun01() {
		cout << "可以和我说话哦~" << endl;
	}

private:
	void mFun02() {
		cout << "这是我的心里面话，只会对我的朋友说哦~" << endl;
	}

};


// 我是 person01_xy 的朋友
void fun01() {
	person01_xy p1;
	p1.mFun01();
	// 我们是好朋友，我知道你的心里话哦
	p1.mFun02();
}

// 我对 person01_xy 来说只是一个路人
void fun02() {
	person01_xy p1;
	p1.mFun01();
	// 因为 fun02 和 person01_xy 是陌生人关系，所以 person01_xy 不会和 fun02 说心里话
	// p1.mFun02();
}


int main() {
	fun01();
	cout << "------------------分界线------------------" << endl;
	fun02();


	cout << endl;
	system("pause");
	return 0;
}

---

类做友元【Class12】

// 友元 -- 类做友元
#include <iostream>

using namespace std;


class goodGay_xy;
class person01_xy {
	// 加上这句我就承认 goodGay_xy类 是我的好基友了
	friend class goodGay_xy;

public:
	person01_xy();

public:
	string str1;

private:
	string str2;

};

// 我并没有承认 person01_xy 是我的好朋友
class goodGay_xy {
public:
	// 声明我的好基友 person01_xy
	goodGay_xy();
	// 释放我的好基友 person01_xy
	~goodGay_xy();

public:
	void mFun01() {
		cout << "我们之间可以进行交流的程度为：" << person01->str1 << endl;
	}

	void mfun02() {
		// person01_xy 已经承认我是他的好基友了，我当然可以访问他的私有成员了
		cout << "我们之间可以进行交流的程度为：" << person01->str2 << endl;
	}

private:
	person01_xy* person01;

};

// 我只是一个普通的陌生人
class person02_xy {
public:
	// 声明普通的陌生人 person01_xy
	person02_xy() {
		person02 = new person01_xy;
	}

	// 释放普通的陌生人 person01_xy
	~person02_xy() {
		delete person02;
	}

public:
	void mFun01() {
		cout << "我们之间可以进行交流的程度为：" << person02->str1 << endl;
	}

	void mfun02() {
		// person01_xy 没有说我是他的朋友，所以我不能访问他私有的成员
		// cout << "我们之间可以进行交流的程度为：" << person02->str2 << endl;
		cout << "person01_xy 还没有承认我是他的朋友，不愿意跟我说心里话" << endl;
	}
	
private:
	person01_xy* person02;

};

// 类外写成员函数【需要标明是那个作用域下面的成员函数】
person01_xy::person01_xy() {
	str1 = "普通的沟通";
	// 这是自己人，可访问私有的
	str2 = "可以说心里话";
}

goodGay_xy::goodGay_xy() {
	// 这是自己人，可访问私有的
	person01 = new person01_xy;
}

goodGay_xy::~goodGay_xy() {
	delete person01;
}


void fun01() {
	cout << "goodGay_xy g1 所能访问的" << endl;
	goodGay_xy g1;
	g1.mFun01();
	g1.mfun02();
	cout << endl;
	cout << "person02_xy p1 所能访问的" << endl;
	person02_xy p1;
	p1.mFun01();
	p1.mfun02();
}


int main() {
	fun01();
	cout << "------------------分界线------------------" << endl;
	


	cout << endl;
	system("pause");
	return 0;
}

---

成员函数做友元【Class13】

// 友元 -- 成员函数做友元
#include <iostream>

using namespace std;


class person02_xy;
/*
* 不要把 person01_xy 放在 person02_xy 的后面【顺序颠倒了，编译器语法提示不报错，但是开始编译就会报错】
* 我的理解就是，如果颠倒了，前面的声明 class person02_xy;就只是声明了这个类型，并不能找到里面的成员函数，
* 至于在头文件中声明在别的源文件中写实现，会不会出现上面这样的错误还没有测试过
*/
class person01_xy {
public:
	person01_xy();
	void mFun01();
	void mFun02();
	~person01_xy();

private:
	person02_xy* person;

};

class person02_xy {
	/*
	* 加上这句话，我就承认成员函数 mFun01 是我的好基友，可以访问我私有的成员
	* person01_xy与person02_xy互换后，下面这句话在编译的时候就会报错
	*/
	friend void person01_xy::mFun01();

public:
	person02_xy();
	string str1;

private:
	string str2;
};

person02_xy::person02_xy() {
	str1 = "普通交流";
	str2 = "可以说心里话";
}

person01_xy::person01_xy() {
	person = new person02_xy;
}

void person01_xy::mFun01() {
	cout << "我是mFun01，person02_xy承认我是他的好基友,我们可以交流的程度为：" << person->str1 << endl;
	// person02_xy 承认 mFun01 是他的好朋友，所以好朋友可以访问他的私有成员
	cout << "我是mFun01，person02_xy承认我是他的好基友,我们可以交流的程度为：" << person->str2 << endl;
}

void person01_xy::mFun02() {
	cout << "我是mFun02，person02_xy不承认我是他的好基友，我们可以交流的程度为：" << person->str1 << endl;
	// cout << "我是mFun02，person02_xy不承认我是他的好基友" << person01->str2 << endl;
	cout << "我是mFun02，person02_xy不承认我是他的好基友，不会让我访问他的私有成员：" << endl;
}

person01_xy::~person01_xy() {
	delete person;
}


void fun01() {
	person01_xy p1;
	p1.mFun01();
	cout << endl;
	p1.mFun02();
}


int main() {

	fun01();

	cout << endl;
	system("pause");
	return 0;
}

---

一点点笔记，以便以后翻阅。