(1)在类中用friend关键字去声明函数/类，则这个函数/类就会变成友元函数/友元类；
(2)友元函数/友元类的声明位置没有要求，可以在private、protected、public权限区，效果都是一样的；
(3)友元函数/友元类是单向的，A在B类中被声明为友元函数/友元类，表示A是B的友元函数/友元类，但B不是A的友元类函数/友元类；
(4)友元函数/友元类具有和类成员一样的权限，可以访问protected和private权限的成员，但不是类的成员；
(5)友元函数在类中声明时用friend修饰，但是在定义时不需要用friend修饰；
(6)友元函数不能被继承：父类的友元函数，继承后并不会成为子类的友元函数；
(7)友元函数不具有传递性：A类和B类都是C类的友元类，但是A类和B类并不是友元类；
(1)友元函数和非友元函数都是类外函数，不是类的成员函数，所以函数内不能使用this指针来表示类的对象；
(2)友元函数相比于非友元函数，友元函数具有类成员函数一样的权限，可以访问类的protected和private权限下的成员，而非友元函数不可以；
(3)友元函数不是类的成员，所以不能用类的对象去访问友元函数；
#include <iostream>
using namespace std;
class Person
{
private:
int age;
public:
Person(){};
Person(int x);
//声明print是友元函数
friend void print(Person &pn);
};
Person::Person(int x)
{
this->age = x;
}
void print(Person &pn)
{
//因为print是Person类的友元函数，所以在内部可以访问Person类的私有成员age
cout << "age=" << pn.age << endl;
}
int main(void)
{
Person p(22);
print(p);
return 0;
}
#include <iostream>
using namespace std;
class Person;
class Man
{
public:
void print(Person &pn);
};
class Person
{
private:
int age;
public:
Person(){};
Person(int x);
//声明print是友元函数
friend void Man::print(Person &pn);
};
Person::Person(int x)
{
this->age = x;
}
void Man::print(Person &pn)
{
//因为print是Person类的友元函数，所以在内部可以访问Person类的私有成员age
cout << "Man::print" << endl;
cout << "age=" << pn.age << endl;
}
int main(void)
{
Person p(22);
Man M;
M.print(p);
return 0;
}
#include <iostream>
#include <string>
using namespace std;
class Person;
class Man
{
private:
string name;
public:
Man(){};
Man(string myname)
{
this->name = myname;
}
void print_Man(Person &pn);
//声明Person类是友元类
friend class Person;
};
class Person
{
private:
int age;
public:
Person(){};
Person(int x)
{
this->age = x;
}
void print_Person(Man &pn);
//声明Man类是友元类
friend class Man;
};
void Man::print_Man(Person &pn)
{
//因为Man类是Person类的友元函数，Man的成员函数也可以访问Person类的私有成员
cout << "Man::print" << endl;
cout << "age=" << pn.age << endl;
}
void Person::print_Person(Man &pn)
{
//因为Person类是Man类的友元函数，Person的成员函数也可以访问Man类的私有成员
cout << "Person::print" << endl;
cout << "name=" << pn.name << endl;
}
int main(void)
{
Person p(22);
Man M("linux");
//Person和Man互为友元类
p.print_Person(M);
M.print_Man(p);
return 0;
}
(1)当A类被声明为B类的友元类时，则A类中的所有成员函数都可以访问B类private和protected权限成员；
(2)A类和B类可以都声明对方为友元类，则A类和B类互为友元类，都可以访问对方类受保护的成员；
(3)类中包含一个或者多个成员函数，将类声明为友元类，则相当于一次声明了多个友元函数；
总结：友元类可以批量的声明友元函数；
(1)缺点：友元函数不是类的成员但是却具有成员的权限，可以访问类中受保护的成员，这破坏了类的封装特性和权限管控；
(2)优点：可以实现类之间的数据共享；比如上面互为友元类，则可以互相访问对方受保护的成员；
总结：友元函数是一种破坏封装特性的机制，可以让程序员写代码更灵活，但是不能滥用；
我会在C++专栏持续根据更新C++相关的知识点，这里也给大家推荐一款学习C++的神器，我也是在用这一款神器在学习C++。
链接：学习神器跳转
如果你是想入门C++这门语言或者是找C++岗位的工作，都推荐你试试这个网站，里面有针对C++知识点的选择题、编程题，更有C++岗位的面试题，还可以在里面交流行业信息
