C++中的友元

1，友元的超能力在初始的时候能力很好、很实用，但是随着软件工程的发展，大家 越来越觉得友元的超能力是那么的不够友好，于是在实际的开发中，友元的超  能力就被遗弃了；

 

2，友元的概念：

 

    1，友元是 C++ 中的一种关系；

       1，这种关系发生在两个实体之间；

    2，友元关系发生在函数与类之间或者类与类之间；

    3，友元关系时单向的，不能传递；

 

3，友元的解析：

    1，在类中以 frined 关键字声明友元；

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

    3，友元不是类的一部分；

    4，友元不受类中访问级别的限制；

    5，友元可以直接访问具体类的所有成员；

       1，这就是友元的超能力；

   

4，友元的语法：

    1，在类中用 friend 关键字对函数或类进行声明；

    2，代码示例：

class Point
{
    double x;  // 私有；
    double y;  // 私有；
    
    friend void func(Point& p);  // func() 全局函数是 Point 类的友元，func() 可以访问 Point 类的所有成员，但是 func() 不是 Point 的成员函数；
};

void func(Point& p)
{
}

5，友元的使用初探编程实验：

    1，main.cpp 文件：

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

class Point
{
    double x;
    double y;
public:
    Point(double x, double y)
    {
        this->x = x;  // 成员函数有一个 this 指针，用于指向当前对象；
        this->y = y;  // 将参数 y 赋值给当前对象的 y 成员；
    }
    
    double getX()
    {
        return x;
    }
    
    double getY()
    {
        return y;
    }
       
    friend double func(Point& p1, Point& p2);
};

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

/*
    ret = (p2.getY() - p1.getY()) * (p2.getY() - p1.getY()) +
          (p2.getX() - p1.getX()) * (p2.getX() - p1.getX()); //这个式中调用了八次函数，C++ 诞生初期，这么简单的计算要调用八次函数，和 C 相比效率低下，但是 C++ 设计初期要兼容包括 C 的高效等的一切特性，但是面向对象就有信息隐藏，所以诞生了友元；
*/

    ret = (p2.y - p1.y) * (p2.y - p1.y) +
          (p2.x - p1.x) * (p2.x - p1.x);

    ret = sqrt(ret);
    
    return ret;
}

int main()
{
    Point p1(1, 2);
    Point p2(10, 20);
    
    printf("p1(%f, %f)
", p1.getX(), p1.getY());
    printf("p2(%f, %f)
", p2.getX(), p2.getY());
    printf("|(p1, p2)| = %f
", func(p1, p2));
    
    return 0;
}

    2，输出结果：

　　p1(1.000000, 2.000000)

　　p2(10.000000, 20.000000)

　　|(p1, p2)| = 20.124612

   

6，友元的缺陷：

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

    2，友元直接破坏了面相对象的封装性；

       1，私有成员就不应该被外界访问；

    3，友元在实际产品中的高效是得不偿失的；

       1，破坏了封装性，导致很多的开发者将 C++ 作为 C 语言来使用；

    4，友元在现代软件工程中已经逐渐遗弃；

       1，成熟的产品中很少见到友元的身影；

       2，Java、C#、D 这些语言都诞生自 C++，但是都没有支持友元关系；

       3，在以后开发中，如果不是特别的关系，不要使用友元；

   

7，注意事项：

 

    1，友元关系不具备传递性；

    2，类的友元可以是其他类的成员函数；

    3，类的友元可以是某个完整的类；

       1，所有的成员函数都是友元，可以访问所有成员；

      

8，友元的深入分析编程实验：

    1，main.cpp 文件：

#include <stdio.h>

class ClassC
{
    const char* n;  // 用于表示这个类的对象的名字；
public:
    ClassC(const char* n)
    {
        this->n = n;  // 当前对象的初始值需要用构造函数的参数设置；
    }
    
    friend class ClassB;  // B 是 C 的友元；
};

class ClassB
{
    const char* n;
public:
    ClassB(const char* n)
    {
        this->n = n;
    }
    
    void getClassCName(ClassC& c)  // 直接访问 C 的名字；
    {
        printf("c.n = %s
", c.n);
    }
    
    friend class ClassA;  // A 是 B 的友元；
};

class ClassA
{
    const char* n;
public:
    ClassA(const char* n)
    {
        this->n = n;
    }
    
    void getClassBName(ClassB& b)  // 直接访问 B 的名字；
    {
        printf("b.n = %s
", b.n);
    }

    /*
    void getClassCName(ClassC& c)  // 友元不具备传递性；
    {
        printf("c.n = %s
", c.n);  // ‘const char* ClassC::n’ is  private within this context；
    }
    */
};

int main()
{
    ClassA A("A");
    ClassB B("B");
    ClassC C("C");
    
    A.getClassBName(B);
    B.getClassCName(C);
    
    return 0;
}

    2，输出结果：

　　b.n = B

　　c.n = C

   

9，小结：

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

    2，友元直接破坏了面相对象的封装性；

    3，友元关系不具备传递性；

    4，类的友元可以是其它类的成员函数；

    5，类的友元可以是某个完整的类；