目录
友元函数：
友元成员函数：
友元类：
友元是否有悖于OOP?
总结：
- 类因为具有封装和信息隐藏的特性（类外函数无法访问类的私有、保护成员），C++提出友元解决特定的编程需要；
- 友元分为三类：友元函数、友元成员函数、友元类
- 类中友元虽然不是类的成员函数，但是可以访问类的私有成员
友元函数：
友元函数既可以是一个不属于任何类的普通函数也可以是一个类的成员函数，友元函数可以访问类的私有成员(private）和保护成员（protected)
普通函数作为友元函数：
friend 返回值类型 函数名 （参数列表）class B
{
private :
int a;
int b;
protected:
int aa;
public:
int c;
B(int i=1, int j=2,int k=3,int t=4) :a(i), b(j) ,c(k),aa(t){};
void show(){ cout << "a:" << a << ",b:" << b << ",c:" << c << ",aa:" << aa << endl; }
friend void geta(B& b1);//友元函数
};
void geta(B& b1) //B 的友元函数
{
cout << "class B 的私有成员a:" << b1.a << endl;
cout << "class B 的保护成员aa:" << b1.aa<< endl;
}
int main()
{
B b;
b.show();
geta(b);
}
友元成员函数：
友元成员函数格式 相比 友元函数，多了（类名：：）限定
friend 返回值类型 类名：：函数名（参数列表）;代码示例，一个类的成员函数访问另一个类的私有成员
//友元成员函数：
class peo;
class th//销售产品：
{
int banana;
int apple;
public:
th(int a=5, int b=4) :banana(b), apple(a) {};//构造函数 初始化
int sum(const peo& p);//求销售总额
};
class peo//销售人数
{
private:
int b_p;
int a_p;
public:
peo(int a = 4, int b = 5) :b_p(b), a_p(a) {};
friend int th::sum(const peo& p);//类的成员函数声明为友元成员函数
};
int th::sum(const peo& p)
{
return p.a_p * apple + p.b_p * banana;
}
int main()
{
peo a;
th b;
cout << "销售总额为："<<b.sum(a) << endl;
}
友元类：
类A 中所有的成员函数都想访问 类B中的私有和保护成员，则在类B 中声明 类A为其的友元类。
在哪个类中声明，哪个类就被访问
友元类 有另一种较为繁琐的实现方式：将类A 所有的成员函数声明为 B 的友元成员函数。
friend class 类名//友元类
class Date //日期类
{
private:
int year;
int month;
int day;
public:
Date(int y=0, int m=0, int d=0) :year(y), month(m), day(d)
{}
friend class DateFriend; //友元类,DateFriend是自己(Date类)的友元类
};
class DateFriend
{
public:
void modifyDate(Date& date, int year, int month, int day);//修改日期
void show(const Date& date);//输出数据
};
void DateFriend::modifyDate(Date& date, int year, int month, int day)//修改日期
{
date.day = day;
date.month = month;
date.year = year;
}
void DateFriend::show(const Date& date)//输出数据
{
cout << date.year << "-" << date.month << "-" << date.day<<endl;
}
int main()
{
Date a(2023, 12, 20);
DateFriend b;
b.show(a);
b.modifyDate(a,2024,1, 26);
b.show(a);
return 0;
}
友元是否有悖于OOP?
友元机制允许非成员函数访问保护成员、私有成员（违反了OOP数据隐藏原则）？
解答：
友元任然遵循OOP ：友元函数可看做类的扩展接口的组成部分，每次友元的声明都在类内，即在类有控制与选择的基础上声明友元，类自愿将私有保护成员分享给被声明的类或者函数，使得该函数有权限访问类外函数无法访问的数据（声明类被访问），并没有破坏OPP。
总结：
| 类的友元函数： | 函数访问类内私有、保护成员 | |
| 类的成员友元函数： | ||
| 类的友元类： | 友元类访问类内私有、保护成员 | |
