第28课 友元的尴尬能力

友元的概念：

友元的用法：

 程序示例：

 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 }

运行结果如下：

友元函数可以提高效率，因为在32、33行我们可以直接访问对象中的成员了，而不再使用功能函数。

友元的尴尬：

注意事项：

示例：

 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 }

46-49行的程序是不合法的，因为A不是C的友元，友元不能传递。

运行结果如下：

 小结：