實際工程開發逐漸被遺棄；

什麼是友元？

- 友元是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 }