友元的尴尬能力

实际工程开发逐渐被遗弃；

什么是友元？

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

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

-友元是单项的，不能传递。

函数————》（友元）————》class；

友元的用法：

-在类中以friend 关键字声明友元

-类的友元可以是其它类或者具体的函数

-友元不是类的一部分

-友元不受类中访问级别的限制

-友元可以直接访问具体类中的所以的成员

友元不受的priv限制，可以访问全体成员，它是外部的实体，不受类的限制

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

 1 #include <stdio.h>
 2 #include <math.h>
 3 
 4 class Point
 5 {
 6     double x;
 7     double y;
 8 public:
 9     Point(double x, double y)
10     {
11         this->x = x;
12         this->y = y;
13     }
14     
15     double getX()
16     {
17         return x;
18     }
19     
20     double getY()
21     {
22         return y;
23     }
24        
25     friend double func(Point& p1, Point& p2);
26 };
27 
28 double func(Point& p1, Point& p2)
29 {
30     double ret = 0;
31     
32     ret = (p2.y - p1.y) * (p2.y - p1.y) +
33           (p2.x - p1.x) * (p2.x - p1.x);
34           
35     ret = sqrt(ret);
36     
37     return ret;
38 }
39 
40 int main()
41 {
42     Point p1(1, 2);
43     Point p2(10, 20);
44     
45     printf("p1(%f, %f)\n", p1.getX(), p1.getY());
46     printf("p2(%f, %f)\n", p2.getX(), p2.getY());
47     printf("|(p1, p2)| = %f\n", func(p1, p2));
48     
49     
50     return 0;
51 }

友元的尴尬能力：

-友元是为了兼顾C的高效而诞生的；

-友元直接破坏了面向对象的封装性；

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

-友元在现代工程中已经被逐渐遗弃。

注意事项：

-友元不具有传递性；

-类的友元可以是其他类的成员函数

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

　　 -所有的成员函数都是友元。

友元不具有传递性.cpp:

 1 #include <stdio.h>
 2 
 3 class ClassC
 4 {
 5     const char* n;
 6 public:
 7     ClassC(const char* n)
 8     {
 9         this->n = n;
10     }
11     
12     friend class ClassB;
13 };
14 
15 class ClassB
16 {
17     const char* n;
18 public:
19     ClassB(const char* n)
20     {
21         this->n = n;
22     }
23     
24     void getClassCName(ClassC& c)
25     {
26         printf("c.n = %s\n", c.n);
27     }
28     
29     friend class ClassA;
30 };
31 
32 class ClassA
33 {
34     const char* n;
35 public:
36     ClassA(const char* n)
37     {
38         this->n = n;
39     }
40     
41     void getClassBName(ClassB& b)
42     {
43         printf("b.n = %s\n", b.n);
44     }
45     /*
46     void getClassCName(ClassC& c)
47     {
48         printf("c.n = %s\n", c.n);
49     }
50     */
51 };
52 
53 int main()
54 {
55     ClassA A("A");
56     ClassB B("B");
57     ClassC C("C");
58     
59     A.getClassBName(B);
60     B.getClassCName(C);
61     
62     return 0;
63 }

 

转载于:https://www.cnblogs.com/lemaden/p/10117792.html