28,友元的尴尬能力

1. 友元的概念

(1)友元是C++中的一种关系

(2)友元关系发生在函数与类之间或类与类之间

(3)友元关系是单项的，不能传递

class Point
{
    double x;
    double y;
    friend void func(Point& p);  //声明func为Point类的友元函数-----将Point类和全局函数finc()联系起来，----使得func()具有的超能力，可以访问Point全部成员
} 

void func(Point& p){};     //全局函数，参数是类的引用，接受一个Ponit对象p作为参数---------通过参数对象名p，可以访问Point类内的任何成员！

2. 友元的用法

（1）在类中以friend关键字声明友元

（2）类的友元可以是其它类或者具体函数

（3）友元不是类的一部分，也不受类中访问级别的限制，可以直接访问具体类的所有成员--------超能力

（4）用友元的注意事项

　　①友元关系不具备传递性

　　　　　　 

　　②类的友元可以是其它类的成员函数（即其它类的成员函数作为该类的友元函数）

　　③类的友元可以是某个完整的类（即所有的成员函数都是友元）

#include <stdio.h>
#include <math.h>

class Point
{
private:

    double x;
    double y;

public:

    Point(double x, double y)
    {
        this->x = x;
        this->y = y;
    }

    double getX(){return x;}
    double getY(){return y;}

    void getXY()
    {
        printf("x = %f, y = %f
", x, y);
    }

   friend double Distance(Point& p1, Point& p2);  //Distance是point的友元，Distance可以访问类的一切成员,main不可以

};



double Distance(Point& p1, Point& p2)
{
     double ret = 0;

     //ret=sqrt((p2.x-p1.x)*(p2.x-p1.x) +

              (p2.y-p1.y)*(p2.y-p1.y));     //error-----------Distance全局函数与point没有关系，Distance是类的外部，当然不能引用类中的私有成员!
    //上面改写成
     ret = (p2.getY()- p1.getY()) * (p2.getY() - p1.getY()) +
           (p2.getX() - p2.getX()) * (p2.getX() - p1.getX());    //调用8次函数，效率低，---引入友元解决

     //引入友元
     ret = (p2.y()- p1.y()) * (p2.y() - p1.y()) +
           (p2.x() - p2.x()) * (p2.x() - p1.x());

     ret=sqrt(ret);

     return ret;

}

int main()
{
    Point p1(1, 2);

    Point p2(10, 20);

    p1.getXY();

    p2.getXY();

    printf("p1(%f,%f)
", p1.getX(), p1.getY());          //mian 和Point
    printf("p2(%f,%f)
", p2.getX(), p2.getY());
    printf("|(p1,p2)|=%f
", Distance(p1, p2));

    return 0;

}

3. 友元的尴尬

（1）友元是为了兼顾C语言的高效而诞生的，但直接破坏了面向对象的封装性（每个类定义的私有成员，不能被外界访问）c++当作c语言，不符合初心

（2）友元在实际产品中的高效是得不偿失的，在现代软件工程中己经逐渐被遗弃

【编程实验】友元的深入分析

#include<stdio.h>  

//类与类之间也有友元关系，但是没有传递性
//破坏了对象的封装性，如：不能随便访问类的私有成员

class Classc
{
    const char* n;      //字符指针，n表示类对象的名字
public:
    Classc(const char* n)
    {
        this->n = n;    //this指向当前调用类的对象
    }

    friend class Classb;        //友元，b可以访问c的私有成员
};

class Classb
{
    const char* n;             //字符指针，n表示类对象的名字
public:
    Classb(const char* n)
    {
        this->n = n;
    }

    //访问c的名字，就可以访问类Classc的各个数据元素
    void getClassName(Classc& c)
    {
        printf("c.n=%s
", c, n);
    }

    friend class Classa;            //友元，a可以访问b的私有成员
};

class Classa
{
    const char* n;                  //字符指针，n表示类对象的名字
public:
    Classa(const char* n)
    {
        this->n = n;
    }

    //访问b的名字，就可以访问到Classb的数据元素
    void getClassName(Classb& b)
    {
        printf("b.n=%s
", b, n);
    }

};


int main()
{
    //A是B的友元类，B是C的友元类，但A不能自动传递为C的友元类

    Classa A("O");
    Classb B("P");
    Classc C("Q");

    A.getClassName(B);  //B
    B.getClassName(C);  //c


    return 0;
}

4. 小结

（1）友元是为了兼顾C语言的高效而诞生的

（2）友元直接破坏了面向对象的封装性

（3）友元关系不具备传递性

（4）类的友元可以是其它类的成员函数

（5）类的友元可以是某个完整的类