C++的友元函数和友元类  1.什么是友元函数【1】外部函数访问类内成员写一个Person类，内部有private、protected、public的三类访问权限的成员写一个外部函数disp_info来打印这三类成员#include <iostream>using namespace std;class person{public:    int age;    person(){};    person(int age,int height,string name);protected:    int height;private:    string name;    };//构造函数person::person(int age,int height,string name){    this->age = age;    this->height = height;    this->name = name;}//类外的函数void disp_info(person& pn){    cout << "age = " << pn.age << endl;            //public的，类外可以访问    cout << "height = " << pn.height << endl;      //protected的，类外不可以访问    cout << "name = " << pn.name << endl;          //private的，类外不可以访问}int main(int argc, char const *argv[]){    person p1(10,155,"jime");    disp_info(p1);    return 0;}总结：可以访问public的，但是protected和private的无法访问想办法：除非把disp_info挪到Person类内部成为成员函数，否则没办法 【2】友元函数的引入将外部函数disp_info声明为Person类的友元函数即可解决class person { public:    int age;    person(){};    person(int age,int height,string name);    //声明外部函数为类的友元函数    friend void disp_info(person& pn); protected:    int height; private:    string name;     };【3】总结      友元函数不是本类的成员函数，而是一个外部函数       友元函数的标志就是在类内部加friend关键字来声明       友元函数声明的位置不要求，写在private或者protected或者public内都可以，反正只要有声明就行       一个外部函数成为类的友元后，访问权限被扩展了，等同于类的内部成员函数了       友元函数是单向的。例如一个类A外部有函数fun()，函数里有一个局部变量i；当fun()函数声明为A的友元函数，意为着fun()函数能访问类A里面的所有权限的成员，而类A却不能访问函数fun()里面的变量i       友元函数就好像在类的封装和访问权限保护上打了个“洞”，所以是对面向对象的一种破坏，所以不能滥用     2.友元函数的第二种实现 【1】友元函数的2种实现友元函数为外部函数（上面已经实现）友元函数为另一个类中的成员函数（也叫友元成员，友元成员方法，友元成员函数） //- 友元函数为另一个类中的成员函数的实现代码#include <iostream>using namespace std;class person;      //类的前置声明class animal{public:    void eat(person& pn);    //这里只用到一个person类的引用，不涉及person里面的具体细节，所以能编译通过};class person{public:    int age;    person(){};    person(int age,int height,string name);    friend void animal::eat(person& pn);protected:    int height;private:    string name;    };//构造函数person::person(int age,int height,string name){    this->age = age;    this->height = height;    this->name = name;}void animal::eat(person& pn){    cout << "animal eat a person nameed" << pn.name << endl;    cout << "animal eat a person age = " << pn.age << endl;    cout << "animal eat a person height = " << pn.height << endl;}int main(int argc, char const *argv[]){    person p1(10,155,"jime");    animal a1;    a1.eat(p1);    return 0;} 【2】类的前置声明      两个类要互相引用，就会出现“未定义”尴尬，此时可以用前置声明来解决       前置声明不包括类的详细信息，所以编译器无法得到前置声明类的大小，成员等详细信息       不能试图通过前置声明解决类成员的调用   class animal;      //类的前置声明class person{public:    int age;    person(){};    person(int age,int height,string name);    friend void animal::eat(person& pn);     //编译报错，不能通过animal类的前置声明就调用animal里面的eat（）成员protected:    int height;private:    string name;    };class animal{public:    void eat(person& pn);    };   不能试图通过前置声明来定义类的对象，只能改为定义类对象的指针或引用。 class person;      //类的前置声明class animal{public:    void eat(person& pn);    //这里只用到一个person类的引用，不涉及person里面的具体细节，所以能编译通过    //person p1;             //不可以    person *p2;              //定义成指针和引用都可以};class person{public:    int age;    person(){};    person(int age,int height,string name);    friend void animal::eat(person& pn);protected:    int height;private:    string name;    };   3.友元类 【1】友元类的概念和使用#include <iostream>using namespace std;class person;      //类的前置声明class animal{public:    void eat(person& pn);        void love(person& pn); };class person{public:    int age;    person(){};    person(int age,int height,string name);    friend class animal;       //将animal整个类声明为person类的友元类protected:    int height;private:    string name;    };//构造函数person::person(int age,int height,string name){    this->age = age;    this->height = height;    this->name = name;}void animal::eat(person& pn){    cout << "animal eat a person nameed" << pn.name << endl;    cout << "animal eat a person age = " << pn.age << endl;    cout << "animal eat a person height = " << pn.height << endl;    cout << endl;}void animal::love(person& pn){    cout << "animal love a person nameed" << pn.name << endl;    cout << "animal love a person age = " << pn.age << endl;    cout << "animal love a person height = " << pn.height << endl;}int main(int argc, char const *argv[]){    person p1(10,155,"jime");    animal a1;    a1.eat(p1);    a1.love(p1);    return 0;}             将类animal声明为person中的friend class后，则animal中所有成员函数都成为类person的友元函数了       友元类是单向的；2个类可以互为友元类   【2】友元类总结      友元类其实就是批量制造友元函数       友元类中所有全部成员都成为了友元函数，相当于一次打了很多洞，极大破坏了面向对象       除非确实有必要，否则建议按需定义友元函数，尽量维护面向对象，让代码更安全健壮     4.关于友元函数 【1】使用友元函数的优缺点缺点：破坏了封装机制，尽量不使用友元函数，不得已才使用友元函数优点：在实现类之间数据共享时，减少系统开销，提高效率。【2】使用友元函数的两种情况运算符重载的某些场合需要使用友元两个类要共享数据的时候【3】运算符重载中使用友元#include <iostream>using namespace std;class coordinate{public: int x;     // x轴坐标 int y;     // y轴坐标  coordinate(); coordinate(int x0, int y0);  // 拷贝构造函数 coordinate(const coordinate& rhs);  void print(void);  friend coordinate operator+(const coordinate& a, const coordinate& b); };coordinate::coordinate(){ x = 0; y = 0;};coordinate::coordinate(int x0, int y0){ x = x0; y = y0;};// 拷贝构造函数coordinate::coordinate(const coordinate& rhs){ cout << "---copy construtor---" << endl; this->x = rhs.x; this->y = rhs.y;}void coordinate::print(void){ cout << "(" << this->x << ", " << this->y << ")" << endl;}// 用独立函数来实现+的运算符重载coordinate operator+(const coordinate& a, const coordinate& b){ coordinate tmp;  tmp.x = a.x + b.x; tmp.y = a.y + b.y;  return tmp;}int main(void){ coordinate a(1, 3); coordinate b(2, 4); coordinate c;  c = a + b;   //  a+b 就相当于是 c = operator+(a, b);// c = b + a;   // 相当于 c = operator+(b, a);  a.print(); b.print(); c.print(); return 0;}并非所有运算符重载都可用友元函数，有四个运算符 =, ->, [], ()就不可以详解可参考：解析C++中不能重载为友元函数的四个运算符 【4】两个类如何共享数据      类内的数据，其实就是类的成员变量       2个类共享数据方法1：将共享数据访问权限设置为public。       2个类共享数据方法2：通过第三个专门封装数据的类，和2个类中带参数的成员函数来传参共享       2个类共享数据方法3：通过友元函数打洞       【5】友元函数和类的成员函数的区别      成员函数有this指针，而友元函数没有this指针。为什么？因为友元只是朋友，并不是类内“自家人”       友元函数是不能被继承的，就像父亲的朋友未必是儿子的朋友。       友元关系不具有传递性。类B是类A的友元，类C是B的友元，类C不一定是类A的友元，要看类中是否有相应的声明   【6】共有友元函数      1个函数同时成为2个类的友元函数       共有友元函数可以是外部函数，也可以是某个（第3个）类的成员函数       共有友元函数内可同时访问2个类的受保护成员，间接将2个完全无关的类的数据打通了