友元总结

友元函数可以访问与其有好友关系类对象的数据成员，但不属于类的成员函数，因而没有this指针不能直接使用类的数据成员，需要利用引用来创建一个类的对象，才可以使用数据成员

代码说明如下

一个函数为类的友元函数

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class Clock
 5 {public:
 6     Clock(int h,int m,int s);
 7 
 8     friend void Display(Clock &t); //将Display()函数声明为Clack类的友元函数，此处写不写对象t都可以，关键在于声明为引用
 9 
10 private:
11     int hours;
12     int minute;
13     int second;
14 };
15 
16 Clock::Clock(int h.int m,int s)
17 {
18     hours=h;
19     minute=m;
20     second=s;
21 }
22 
23 void Display(Clock &t) //利用引用创建一个类的对象
24 {
25     cout<<t.hours<<","<<t.minute<<","<<t.second<<endl;
26 }
27 
28 int main()
29 {
30     Clock t(10,16,52); //类创建引用对象t
31     Display(t);   //调用Display（）函数，实参t是Clock的对象
32     return 0;
33 }

一个函数同时为两个类的友元函数

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class Date;  //此处先声明类，因为接下来就需要使用，否则找不到,向前引用声明
 5
 6 class Clock
 7 {public:
 8     Clock (int ,int,int );
 9     friend void show(Date &,Clock &);   //此处的对象可写可不写，引用两个类的对象，写两个
10 
11 private:
12     int hour;
13     int minute;
14     int second;
15 };
16 
17 Clock::Clock(int h,int m,int s)
18 {
19     hours=h;
20     minute=m;
21     second=s;
22 }
23 
24 class Date
25 {public:
26     Date (int,int,int);
27     friend void show(Date &,Clock &);   //此处的对象可写可不写 ，引用两个类的对象，写两个
28 
29 private:
30     int year;
31     int month;
32     int day;
33 };
34 
35 Date::Date(int y,int m,int d)
36 {
37     year=y;
38     month=m;
39     day=d;
40 }
41 
42 void show(Date &d,Clock &t)    //友元函数
43 {
44     cout<<d.year<<d.month<<d.day<<endl;
45     cout<<t.hours<<t.minute<<t.second<<endl;
46 }
47 
48 int main()
49 {
50     Date d(2001,1,4);  //类创建引用对象d
51     Clock t(5,10,25);    //类创建引用对象t
52 
53     show(d,t);  //调用show（）函数，实参d为类Date的对象，实参t为类Clock的对象
54     return 0;
55 }

一个类的成员函数作为另一个类的友元函数

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class Date;  //此处先声明类，因为接下来就需要使用，否则找不到，向前引用声明
 5 
 6 class Clack;
 7 {public:
 8     Clock (int,int,int);
 9     void Display(Date &);
10 
11 private:
12     int hours;
13     int minute;
14 i    nt second;
15 };
16 
17 class Date
18 {public:
19     Date(int,int,int);
20     friend void Clock::Display(Date &);
21 
22 private:
23     int year;
24     int month;
25     int second;
26 }；
27 
28 …………   //Clock的构造函数
29 …………   //Date的构造函数
30 
31 void Clock::Display(Date &d) 
32 {
33     cout<<d.year<<d.month<<d.day<<endl;   //Display为Date的友元函数，利用引用创建的对象来调用数据成员
34     cout<<hour<<minute<<second<<endl;     //Display为Clock的成员函数，含有隐藏的this指针，可以直接调用本类的数据成员
35 }
36 
37 int mian()
38 {
39     Clock clock(8,10,15);  //创建类Clock的对象
40     Date date(2015,10,30);  //创建类Date的对象
41 
42     return 0;
43 }

友元类：把一个类声明为另一个类的友元，即：该类中的所有函数都可以被另一个类访问，所有函数都为友元函数

 1 #include <iostream>
 2 using namespace std;
 3 class Date;  //此处先声明类，因为接下来就需要使用，否则找不到
 4 class Clock
 5 {public:
 6     Clock (int,int,int);
 7     void Display(Date &);  //Clock中所有的函数都为Date的友元函数
 8 
 9 private:
10     int hours;
11     int minute;
12     int second;
13 };
14 
15 class Date
16 {public:
17     Date (int,int,int);
18     friend Clock;   //Clock为Date的友元类
19 
20 private:
21     int month;
22     int day;
23     int year;
24 };
25 
26 …………  //Clock的构造函数
27 …………  //Date的构造函数
28 
29 void Clock::Display(Date &d)
30 {
31     cout<<d.year<<d.month<<d.day<<endl;
32     cout<<hours<<minute<<second<<endl;
33 }
34 
35 int main()
36 {
37     Clock clock(8,50,15);
38     Date date(2015,12,20);
39     clock.Display(date);
40 
41     return 0;
42 }

注：为谁的友元就在后面写谁

猜你喜欢