友元函数的总结

1.关键字friend只出现在类定义的内部（这点与const不同）

2.友元是授予友元关系的那个类的成员

3.定义类B为类A的友元，B可以访问A的私有成员

[cpp]  view plain  copy

1. 例1：/*要注意友元的使用顺序，声明B->定义A->定义B*/    
2. class B;/*只声明而未定义的类称为不完全类，可用定义类型，不能用于定义对象*/    
3. class A    
4. {    
5. private:    
6.     int x;    
7. public:    
8.     A(int i):x(i){}    
9.     friend B;/*将B声明为友元，B可以访问A的private*/    
10. };    
11. class B    
12. {    
13. private:    
14.     int x;    
15. public:    
16.     void Test(A a)    
17.     {    
18.         x = a.x;    
19.     }    
20.     int Get(){return x;}    
21. };    
22. int main()    
23. {    
24.     A a(3);    
25.     B b;    
26.     b.Test(a);    
27.     //输出3.说明Test()函数赋值成功，也说明Test()中的x是B的成员，从而得知，Test()是属于B的     
28.     cout<<b.Get()<<endl;    
29.     return 0;    
30. }    

4.定义类B的Test()函数为类A的友元，B的Test()函数可以访问A的私有成员

[cpp]  view plain  copy

1. 例2：/*要注意友元的使用顺序， 
2. 声明A->定义B(要作为友元的那个函数只声明不定义)->定义A->定义B的函数*/  
3. class A;/*只声明而未定义的类称为不完全类，可用定义类型，不能用于定义对象*/  
4. class B  
5. {  
6. private:  
7.     int x;  
8. public:  
9.     void Test(A a);  
10.     int Get(){return x;}  
11. };  
12. class A  
13. {  
14. private:  
15.     int x;  
16. public:  
17.     A(int i):x(i){}  
18.     friend void B::Test(A a);/*将B的Test()声明为友元，B的Test()可以访问A的private*/  
19. };  
20. void B::Test(A a){x = a.x;}  
21. int main()  
22. {  
23.     A a(3);  
24.     B b;  
25.     b.Test(a);  
26.     //输出3.说明Test()函数赋值成功，也说明Test()中的x是B的成员，从而得知，Test()是属于B的  
27.     cout<<b.Get()<<endl;  
28.     return 0;  
29. }  

5.友元声明将已命名的类或非成员函数引入到外围作用域中。此外，友元函数可以在类的内部定义，该函数的作用域扩展到包围该类定义的作用域。

例3：

[cpp]  view plain  copy

1. /*本来A和f()的作用域只限于在它们声明之后。 
2. 但是因为类B提前引入了它们，使得它们的作用域与类B的作用域相同*/  
3. class B  
4. {  
5.     friend class A;  
6.     friend void f();  
7. };  
8. class C  
9. {  
10. public:  
11.     A *p;  
12.     void g(){return f();}  
13. };  
14. class A;  
15. void f()  
16. {  
17.     cout<<"1"<<endl;  
18. }  
19. int main()  
20. {  
21.     C c;  
22.     c.g();//输入1  
23.     return 0;  
24. }  

6.友元函数的重载函数，如果要成为友元，必须要用friend声明。

例4：

[cpp]  view plain  copy

1. class A;/*只声明而未定义的类称为不完全类，可用定义类型，不能用于定义对象*/  
2. class B  
3. {  
4. private:  
5.     int x;  
6. public:  
7.     void Test(A a);  
8.     void Test(A a1, A a2);  
9.     void Test(A a1, A a2, A a3);  
10.     int Get(){return x;}  
11. };  
12. class A  
13. {  
14. private:  
15.     int x;  
16. public:  
17.     A(int i):x(i){}  
18.     friend void B::Test(A a);/*将B的Test()声明为友元，B的Test()可以访问A的private*/  
19.     friend void B::Test(A a1, A a2);  
20. };  
21. //正确，因为已经被定义为友元  
22. void B::Test(A a){x = a.x;}  
23. //正确，因为已经被定义为友元  
24. void B::Test(A a1, A a2){x = a1.x + a2.x;}  
25. //错误，不能因为Test(A a)是友元，就认为它的重载也是友元  
26. void B::Test(A a1, A a2, A a3){x = a1.x + a2.x + a3.x;}