一、友元

1、啥是友元？

友元就是friend修饰函数或者类,友元只是单纯的提供一个场所赋予对象具有无视权限功能（不是说直接可以访问另一个数据）

2、友元函数

1、友元函数不属于类，就是一个普通函数，类外实现不需要类名限定
2、以另一类的成员函数当做友元函数，要注意写法（注意顺序(声明与定义的顺序—必需先声名后定义)）
3、友元函数无论啥属性都可以，即无论是public、private、protected

#include<iostream>
#include<string>
using namespace std;
class MM {
public:
	MM() {}
	MM(string name,int age):name(name),age(age){}
	void print() {             //普通函数
		cout << name << "\t" << age << endl;
	}
	friend void printMM(MM&object);
protected:
	friend void printData(MM&object) {			//友元函数
		cout << "MM中的printData" << endl;
	}
protected:
	string name;
	int age;
};
void printMM(MM&object){
	name="李白";
	age=1000;
	cout<<name<<"\t"<<age<<endl;
}
int main() {
	MM mm("张飞", 19);
	mm.print();				//普通函数的调用
	printData(mm);			//友元函数的调用
	printMM(mm);
	while (1)
	{

	}
	return 0;
}

注意：友元函数在类外定义的时候，无需使用类名限定

3、友元类

在另一个中用friend修饰声明类，称之为友元类,友元类一般是在一个类中声名一个友元类

#include <iostream>
using namespace std;
class Boy 
{
	friend class Girl;		//友元类
public:
	Boy(string name, int age) :name(name), age(age) {}
private:
	void printBoy() 
	{
		cout << name << "\t" << age << endl;
	}
	string name;
	int age;
};

class Girl 
{
public:
	Girl(string name, int age) :boy(name, age) 
	{

	}
	void printInfo() 
	{
		cout << boy.name << "\t" << boy.age << endl;	//无视权限
		Boy* pB = new Boy("new", 19);			
		pB->printBoy();									//无视权限
	}
private:
	Boy boy;
};
//互为友元类

class Test
{
	friend class Data;
public:
	void printTest();
private:
	void test() 
	{
		cout << "测试权限专用函数" << endl;
	}
};
class Data
{
	friend class Test;
public:
	void printData()
	{
		Test tObject;
		tObject.test();
	}
private:
	void data()
	{
		cout << "测试权限专用函数" << endl;
	}
};
void Test::printTest() 
{
	Data dObject;
	dObject.data();
	cout << "printTest" << endl;
}
int main() 
{
	Test test;
	test.printTest();

	Data data;
	data.printData();
	return 0;
}

二、类中默认存在的函数

一、

当我们使用类创建对象的时候，有时我们明明没有写构造函数，但我们依然可以使用无参构造函数去构造对象。但我们如果只写了有参构造函数，那我们就只能使用有参的方式构造对象，无法使用无参方式构造对象，这是为什么呢？
答：类中存在默认的构造函数—无参构造函数，当我们直接写了有参构造函数，原来默认的构造函数就会被覆盖（简单点说就是不存在了)。所以如果我们既要有参构造函数也需无参构造函数，那就需要都写上了。

二、类中除了存在默认的无参构造函数，还存在哪些默认的函数呢？
1.默认构造函数

MM() = default; //可以使用default表示该函数是使用的默认的

2、默认析构函数

~MM() = default;

3.默认的拷贝构造函数

MM(const MM& object) = default;

4.默认的赋值重载

MM& operator=(const MM& object) = default;

注意一般情况下，无需我们自己写析构函数。但如果我们做了内存申请，为了更好的内存管理就需要自己写析构函数。

三、代码详情

#include <iostream>
#include <string>
using namespace std;
class MM 
{
public:
	MM() = default;
	~MM() = default;
	MM(const MM& object) = default;
	MM& operator=(const MM& object) = default;
	//1.默认构造函数
	//2.默认析构函数
	//3.默认的拷贝构造函数
	//4.默认的赋值重载
private:
};
//重载中的特殊情况
//对象加常量的情况
class Test
{
public:
	Test(int num) :num(num) {}
	void printData() 
	{
		cout << num << endl;
	}
	//正常人处理方法
	//friend Test operator+(Test test, int data) 
	//{
	//	return Test(test.num + data);
	//}
	//friend Test operator+( int data, Test test)   
	//{
	//	return Test(test.num + data);
	//}
	Test operator+(Test test1)
	{
		return Test(this->num + test1.num);
	}

private:
	int num;
};

int main() 
{
	MM mm;
	MM result = mm;
	MM temp;
	temp = mm;
	Test object(1);
	object.printData();

	//不正常的重载只能用友元方式，才可以让下面都正确 
	//友元重载解析:operator+(1,object);  Test objec1=1
	Test res = object + 1;		//友元重载解析:operator+(object,1);
	res.printData();		
	//Test res2 = 1 + object;	//类成员函数重载会报错
	//res2.printData();

	return 0;
}