ipad学习大三课件

1、第3章 类与对象（二）37 特殊成员一、静态数据成员数据共享：全局变量或全局对象：可见性无法控制，故不安全，应尽量少用静态成员：同类对象间共享 是类的成员，不是某个对象的成员 它是同类对象共享的成员，只存储一处，可节省内存，提高效率 定义格式：static 类型符 数据成员名必须进行初始化，其初始化必须在类外进行，前面不加static，格式为：类型符 类名：数据成员名=值 具有静态生存期，是静态存储的，只需初始化一次，以后将保持其值，直至下次改变为止 引用格式：类名 : 静态数据成员名对象名静态数据成员名 /用的是对象的类型属性，少用对象指针-静态数据成员名 /只用其类型属性，少用 它仍受访问

2、权限修饰符：public、protected、private的制约 用于描述类中所有对象共有的属性 其存储分配不在构函中完成，其空间回收也不在析构函数里进行在未建立对象之前，静态成员就已经存在 常用于以下场合：a用来保存流动变化的对象个数b作为一个标志，指示一个特定动作是否发生c用作指向链表第一成员或最后一个成员的指针例：# include iostream.hclass Apublic: A(int i, int j, int k):a(i), b(j), c(k)s+=a+b+c; void show(A d)coutd.sendl; void print()coutsendlA:send

3、l;private: int a, b, c; static int s;int A:s(0);void main()A m(2,3,4), n(5,6,7); m.print(); m.show(n); n.show(m);结果：27272727例：# include iostream.hclass Apublic: A(int c=0):a(c)b+; A()b-; void f()coutaendlbendl;private: int a; static int b;int A:b=0;void g()A d, e=3; e.f();void main()g(); A m(4), n;

4、n=m; n.f();结果：3242例：# include iostream.hclass A public: A()a+; A()a-; void show()coutaendl;private: static int a;int A:a=0;A m;void f()static A b;void g()A n; n.show();A & h()return m;void main()f(); g(); h().show();结果：32# include iostream.hclass Apublic: static int a; int b;int A:a=0;void main()A m

5、,n; m.a=2; m.b=3; n.a=4; n.b=5; coutm.am.bendl; coutn.an.bendl;结果：4345# include iostream.hclass A int a; static int b;public: A(int x=0)a=x; int geta()return a; int getb()return b; void seta(int i)a=i; void setb(int j)b=j;int A:b=0;void main()A *p=new A(2); A *q=new A(3); coutgeta(),getb()endl; cout

6、geta(),getb()setb(4);q-seta(5);q-setb(6); coutgeta(),getb()endl; coutgeta(),getb()endl; delete p; delete q;结果：2,03,02,65,6# include iostream.hclass Apublic: A(int x=0)a=x; b+; A(A & y)a=y.a; b+; A()b-; void show()coutaA:bshow(); A k=A(4),m=5,&n=*q; k.show(); delete p; delete q; m.show();结果：224452# i

7、nclude iostream.hclass Apublic: static int a;int A:a;void main()coutA:aendl; A:a=3; coutA:aendl;结果：03# include iostream.hclass Apublic: A(int i, int j)A:b=i;a=j; A(int k)a=k; void show()coutaA:bendl;private: int a; static int b;int A:b=7;void main()A m(2,3), n(4,5); m.show(); A d(6); d.show();结果：346

8、4# include iostream.hclass Apublic: A(int x, int y)a=x;b=y; static void show()coutbendl;private: int a; static int b;int A:b=0;void main()coutsizeof(A)endl; /4 A:show(); A m(2,3); /0 A:show(); /3 coutsizeof(int)endl; /4 coutsizeof(A)静态成员函数名(参数表) /少用，用的是对象的类型 它与非静态成员函数的根本区别：不能用this指针（无this指针） 不能是虚函数#

9、 include iostream.hclass Apublic: A(int i):a(i)b+=a; static void f(A m);private: int a; static int b;void A:f(A m)coutm.aendlbendl;int A:b=10;void main()A m(3), n(4); A:f(m); n.f(n);结果：317417# include iostream.hclass Apublic: A()cout+aendl; static int geta()return a; A()couta-endl;private: static in

10、t a;int A:a=0;void main()A b,c,d,e,f; coutA:geta()endl;结果：12345554321# include iostream.hclass Apublic: static void add(int m)a+=m; static void show()coutaendl;private: static int a;int A:a=0;void main()A:add(3); A:add(4); A:show();结果：7三、常成员（1）常数据成员 是用const修饰的数据成员 必须初始化，且其值不能被更新，只读 只能通过成员初始化列表的方式生成构

11、造函数来进行初始化 任何函数中都不能对它赋值修改（2）常成员函数 是用const说明的成员函数 只有常成员函数才能引用常对象，即不能用const对象调用非const的普通成员函数 格式：类型符 函数名(参数表)const const加于右边，是函数类型的组成部分，故在函数实现时也应加const 其中不能直接或间接修改数据成员，即只读，也不能通过调用其他成员函数间接修改数据成员 其中不能调用该类中非const成员函数 const可以被用于参与对重载函数的区分 静态成员函数不能声明为常成员函数 该函数的this指针所指向的是常对象 非常对象可以调用常成员函数，常对象不能调用非常成员函数# incl

12、ude iostream.hclass Apublic: A(int i, int j, int k):a(i),c(k)b=j; void show()coutabcendl;private: int a, b; const int c;void main()A m(2,3,4),n(4,5,6); m.show(); n.show();结果：234456# include iostream.hclass Apublic: A(int i):b(i),a(b) void show()coutabcendl; const int & a;private: const int b; static

13、 const int c;const int A:c=7;void main()A m(3), n(4); m.show(); n.show();结果：337447# include iostream.hclass Apublic: A(int i):a(i) const int f() constreturn h()+3; int g()return h()+4; int h()constreturn a;private: const int a;void main()A m(3); const A n(4); const int b=m.f(); const int c=n.f(); co

14、nst int d=m.g(); coutbcdendl;结果：677# include iostream.hclass Apublic: A(int i, int j):a(i),b(j) void show()couta#bendl; void show() constcouta*bendl;private: int a, b;void main()A m(3,4); const A n(5,6); m.show(); n.show();结果：3#45*6# include iostream.hclass Apublic: A(int i=0):a(i) void show()couta#

15、endl; void show() constcouta*endl;private: int a;void f(const A b)b.show();void g(const A & c)c.show();void h(A d)d.show ();A m(3), n(4); const A s(5);void main()f(m); g(n); h(s);结果：3*4*5#38复杂对象一、全局对象和局部对象（1）类域即类的作用域，它介于文件域和函数域之间块域函数域类域文件域程序域类域中的变量只能用static修饰，而不能用register，extern等修饰类域中定义的函数不能用extern修

16、饰（2）对象的生存期指对象从创建开始到被释放为止的存在时间，即该对象的寿命（3）局部对象 被定义在一个函数体内或程序块内，函数参数也是局部对象 其作用域小，生存期短 作用域和生存期相同：从定义处开始到其所在最小分程序结束（4）全局对象 被定义于某文件中 其作用域大，生存期大 作用域与生存期相同：从定义处开始到整个程序结束 安全性较差，使用时应慎重# include iostream.hclass A int x;public: A(int y)x=y; coutConAxendl; A()coutDesAxendl;A a(2);void f(int m)A b(m);void main()f

17、(3); f(4); A c(5), d(6);结果：ConA2ConA3DesA3ConA4DesA4ConA5ConA6DesA6DesA5DesA2# include iostream.hclass Apublic: A(int y):x(y)coutConAxendl; A()coutDesAxendl;private: int x;A a(2), b(3);void main()A c(4); A m(6), n(7); A d(5);结果：ConA2ConA3ConA4ConA6ConA7DesA7DesA6ConA5DesA5DesA4DesA3DesA2二、静态对象（1）存放于

18、静态存储区，定义时其前加static（2）生存期较长：从定义处到整个程序结束（3）分为外部静态对象和内部静态对象，其生存期相同，作用域不同（4）外部静态对象 定义于函数体外 作用域：从定义时开始到其所在文件结束，即文件级 作用域与生存期不同（5）内部静态对象 定义于函数体或程序块内 作用域：从定义时开始到其所在最小分程序结束 作用域与生存期不一致# include iostream.hclass Apublic: A(int y):x(y)coutConAxendl; A()coutDesAxendl;private: int x;A a(2);static A b(3);A c(4);voi

19、d main()A m(5); static A n(6);结果：ConA2ConA3ConA4ConA5ConA6DesA5DesA6DesA4DesA3DesA2# include iostream.hclass Apublic: A(int y):x(y)coutConAxendl; A()coutxDesAendl; A(A & p)x=p.x; coutCopyn;private: int x;void f(A b)static A a(b);void main()A m(4), n(5); f(m); f(n);结果：ConA4ConA5CopyCopy4DesACopy5DesA

20、5DesA4DesA4DesA# include iostream.h# include string.hclass Apublic: A(char * p)strcpy(s,p); coutConAsendl; A()coutDesAsendl;private: char s30;void f()A a(fff);static A b(sssfff);coutIn fn;A c(GGG);static A d(EEEsss);void main()A e(mmm); coutIn main, beforeendl; f(); coutIn main, afterendl;结果：ConAGGG

21、ConAEEEsssConAmmmIn main,betoreConAfffConAsssfffIn fDesAfffIn main, afterDesAmmmDesAsssfffDesAEEEsssDesAGGG# include iostream.h# include string.hclass Apublic: A(char * p)strcpy(s, p); coutConAsendl; A()coutDesAsendl;private: char s30;static A a(Gsaaa);A b(GGG);static A c(:Gsccc);void main()coutIn m

22、ain, beforeendl;static A d(msddd);coutIn main, after成员名（2）指向数据成员的指针 定义：类型符 类名 : * 指针名；或类型符 类名 : * 指针名=& 类名 : 数据成员名； 引用数据成员：对象名*指针名对象指针名-*指针名(* 对象指针名)*指针名（3）指向成员函数的指针 定义：类型符(类名 : * 指针名)(参数表)；或类型符(类名 : * 指针名)(参数表)=类名 : 成员函数名； 引用成员函数：(对象名*指针名)(实参表)或(对象指针名-*指针名)(实参表)或(* 对象指针名)*指针名)(实参表)# include iostrea

23、m.hclass Apublic: A(int i):x(i) void show()coutxy*q=3; p-show(); (*p).*q=4; (*p).show(); m.*q=5; m.show();结果：232425# include iostream.hclass Apublic: A(int y=0)x=y; void set(int j)x=j; void f(A * p)x=p-x+1; void show()coutxset(3);void main()A m(4),n; n.f(&m); m.show(); n.show(); g(m,&n); m.show(); n

24、.show();结果：4543# include iostream.hclass Apublic: A(int i=0)y=i; x+; void disp()coutyendl; static int x;private: int y;int A:x=0;void main()int * p=&A:x; A m(3); m.disp(); cout*pendl; A n(4); n.disp(); cout*pendl;结果：3142# include iostream.hclass Apublic: A(int i):x(i) void show(int y)coutxyshow(3);

25、(p-*q)(4); (*p).show(5); (*p).*q)(6); m.show(7); (m.*q)(8);结果：232425262728# include iostream.hclass Apublic: A(int k):x(k) void set(int i, int j)x=i+j; void show()coutxy*q)(4,5); r-show();结果：93# include iostream.hclass Apublic: A(int i=0)y=i;x+; void disp()coutyendl; static void show()coutxendl;priv

26、ate: static int x; int y;int A:x=0;void main()void (* p)()=A:show; A m(3); m.disp(); p(); A n(4); n.disp(); p();结果：3142# include iostream.hclass Apublic: A(int i=0,int j=0)x=i;y=j; void disp()coutxyendl; int x; int y;void main()A m(2,3); int A:*p; p=&A:x; m.*p=4; p=&A:y; m.*p=5; m.disp(); 结果：45# inc

27、lude iostream.hclass Apublic: A(int i=0,int j=0)x=i; y=j; void disp()coutxendl; void show()coutyendl;private: int x, y;void main()A m(3,4); void (A:*p)(); p=A:disp; (m.*p)(); p=A:show; (m.*p)();结果：34（4）this指针 它是一个指向对象的指针，指向成员函数所属类的正在被操作的对象(当前对象)它是一个指向正在被某个成员函数操作的对象(当前对象)的指针 由系统自动创建，自动使用，用户也可显式使用，通常t

28、his指针的使用是透明的 可用*this来标识当前对象，可用this来标识当前对象的地址 当一个对象调用非静态成员函数时，系统就将该对象的地址赋给this指针。this指针的值随着调用实例的不同而改变 常用于运算符重载和自引用等场合，隐含于成员函数中 它是一个常指针，不能在程序中显式修改它或给它赋值 静态成员不属于任何对象，故不能用this指针调用静态成员。(或称：在静态成员函数中无this指针)例：# include iostream.hclass Apublic: A(int i)x=i; void disp(A * p)coutxxxendl;private: int x;void ma

29、in() A m(3), n(4); m.disp(&m); m.disp(&n); n.disp(&m); n.disp(&n);结果：333334443444例：# include iostream.hclass Apublic: A(int i)x=i; int x;void disp(A * This, A * p) cout(*This).xxxx; A f()this-x=x+10; return *this; A * g()x=this-x+100; return this;private: int x;void main() A m(4),n(5),*p; n=m.f(); p

30、=n.g(); coutget()endl;结果：114# include iostream.hclass Apublic: A(int i)x=i; void show(A p, A * q, A & r) coutxp.xxr.xxprint(); void print()+x; coutxendl;private: int x;void main() A a(2),b(6),&d=a; a.copy(d); a.copy(b); a.disp();结果：9# include iostream.hclass Apublic: A(int i)x=i; void show() coutxxs

31、how();结果：22# include iostream.hclass Apublic: A(int i)x=i; void show() coutxendl; int x=3; coutxxendl; coutxA:xendl; private: int x;void main() A a(2); a.show();结果：23232四、对象引用 常作函数参数 当函数返回值为对象引用时可连续使用成员运算符“”，且函数调用式可作左值# include iostream.hclass Apublic: A(int i)x=i; void s()x=x+10; A & f()s(); return

32、 * this; void show()coutxs(); y.s(); void main() A a(2),b(3),c(4),d(5); a.f().show(); a.f()=b.f().f().f(); a.show(); g(b, &c, d); b.show(); c.show(); d.show();结果：1233331415# include iostream.hclass Apublic: A(int i=0)x=i; A( A & j)*this=j; coutCopyn; void copy(A & p)p=*this; void f(A & m) if(this=&m

33、)coutxendl; else coutxm.xendl; private: int x;void main() A a(2); A & b=a; A d=b; A c(3); c.copy(b); a.f(b); b.f(c); c.f(d);结果：Copy33332五、对象数组（1）对象数组 即元素为对象的数组 定义：类名 对象数组名大小 它可以被赋初值，也可以被赋值 若在定义对象数组时，不想立即对数组中对象赋初值(初始化)，则该类必须含有一个不带参数或带缺省参数的构函，或该类无显式定义的构函# include iostream.hclass Apublic: A(int i=0)x=i

34、; void show()coutxendl; int get()return x;private: int x;A a3;void main() A b4=A(3),A(4),A(5),A(6); a0=b2; a1=A(7); a2=A(b0.get()+6); a0.show(); a1.show(); a2.show();结果：579# include iostream.hclass Apublic: A(int k=0)x=k; coutConAxendl; A()coutxDesAn;private: int x;void main() A * p=new A3; p0=A();

35、p1=A(3); p2=A(4); delete p;结果：ConA0ConA0ConA0ConA00DesAConA33DesAConA44DesA4DesA3DesA0DesA# include iostream.hclass Apublic: A()x=0;coutDefaultxendl; A(int i)x=i; coutConAxendl; A(A & p)x=p.x; coutCopyxendl; A()coutxDesAn;private: int x;A a4;void main() A b2=A(3),A(4), c(5); a0=A(6); a1=A(7); a2=c;

36、a3=b1;结果：Default0Default0Default0Default0ConA3ConA4ConA5ConA66DesAConA77DesA5DesA4DesA3DesA4DesA5DesA7DesA6DesA（2）指向对象数组的指针 定义：类名 (* 指针名)大小# include iostream.hclass Apublic: A(int k=0) x=k; void show()coutx;private: int x;void main()A a23; A (* p)3(a); int i, j;for(i=0;i2;i+) for(j=0;j3; j+) aij=A(i

37、+j+1);for(i=0;i2;i+) coutendl; for(j=0;j3;j+) (*(*(p+i)+j).show(); coutendl;结果：123234（3）对象指针数组 该数组的元素是指向对象的指针 定义：类名 * 数组名大小# include iostream.hclass Apublic: A(int k=0)x=k; void show()coutxendl;private: int x;void main() A a, b(3), c(4), d(5); A * m4=&a, &b, &c, &d; for(int i=0; ishow();结果：0345# inc

38、lude iostream.hclass Apublic: A(int k=0) x=k; coutConAxendl; A()coutxDesAn; void show()coutxshow(); delete r; for(int i=0; i2; i+) delete pi; delete qi; 结果：ConA0ConA0ConA3ConA4ConA5ConA660DesA0DesA3DesA5DesA4DesA6DesA六、常对象（1）常对象 即对象常量，可实现共享数据的保护 定义时必须初始化 常对象的值不能被更新 定义：类名 const 对象名(值);或const 类名 对象名(值

39、); 常对象只能调用它的常成员函数，而不能调用其他成员函数（2）常对象引用 该引用的对象不能被更新 定义：const 类名 & 引用名=对象名; 常作函数的参数，即常参数 A类对象与A类的常对象引用是相适应的，即类型适应类型适应：指一种类型能够在另一种环境中使用，也称赋值相容（3）常对象指针 定义：const 类名 * 指针名=& 对象名; 常作函数的参数，即常参数 它指向的对象值不能改变 对象地址与常对象指针也是相适应的，即赋值相容# include iostream.hclass Apublic: A(int i, int j):x(i), y(j) void show() constco

40、utxyConstn; void show()x=x+y; y=x-y; x=x-y; coutxyshow(); n.show(); k.show();void g(A * m, A & n, A k)m-show(); n.show(); k.show();void main() const A a(12,13), b(14,15), c(16,17); f(&a, b, c); A p(2,3), q(4,5), r(6,7); f(&p, q, r); g(&p, q, r);结果：1213Const1415Const1617Const23Const45Const67Const3254

41、76# include iostream.hclass Apublic: A(int i, int j)x=i; y=j; void show()constcoutxyConstn; void show()x=x+y; coutxshow(); A * const q=&a; * q=b; q-show(); const A * const r=&a; r-show();结果：45Const995Const# include iostream.hclass Apublic: A (int i=0)x=i; coutConAxendl; A()coutxDesAn; void show()cou

42、tx+xendl; void show() constcoutxConstn;private: int x;void f(const A & y)y.show();void main() const int k=3; A m; m=k; m.show(); f(4);结果：ConA0ConA33DesA6ConA44Const4DesA3DesA39 类类型转换一、单参数构造函数具有类型转换功能 可实现标准类型值类类型值的转换 该转换是隐式完成的 也可用赋值运算符重载函数来提高效率# include iostream.hclass Apublic: A(int i=0)x=i;coutConA

43、xendl; void show()coutxendl; A()coutxDesAn;private: int x;void main()A a(3), b=4, c, d, e; int j=6; c=5; d=j; e=A(7); a.show(); b.show(); c.show(); d.show(); e.show();结果：ConA3ConA4ConA0ConA0ConA0ConA55DesAConA66DesAConA77DesA345677DesA6DesA5DesA4DesA3DesA# include iostream.hclass Apublic: A(int i=0)

44、:x(i)coutConAxendl; A()coutxDesAn; void show()coutxendl; A & operator=(int j) x=j; cout*n; return * this;private: int x;void main()A a(3), b=4, c, d, e; int j=6; c=5; d=j; e=A(7); e.show();结果：ConA3ConA4ConA0ConA0ConA0*ConA77DesA77DesA6DesA5DesA4DesA3DesA# include iostream.hclass Apublic: A(int k=0)x

45、=k; coutConAxendl; void show()coutxendl; A()coutxDesAn;private: int x;void main()A a3=3,4,5; for(int i=0; i3; i+) ai.show();结果：ConA3ConA4ConA53455DesA4DesA3DesA# include iostream.hclass Apublic: A(int i)x=i; void show()coutxAn;private: int x;class Bpublic: B(int j)y=j; void show()coutyBn;private: in

46、t y;void f(A & m)m.show();void f(B & n)n.show();void main() f(A(3); f(B(4);/f(3), f(4) 将有二义性结果：3A4B二、类类型转换函数 是类的一种非静态成员函数 定义：class 源类型符public:operator 目标类型符( ); 它将源类型符所标识的类类型转换为目标类型符指定的类型转换方法在转换函数的函数体内定义 它无函数类型，也无参数，不能重载 不能定义为友元函数，只能定义为成员函数 它的函数体中必须有一条return语句，并返回一个具有目标类型的变量或对象 可以被继承，可以是虚函数 当一个类既有单参

47、构函，又有类类型转换成员函数时，可能语法上有二义性，此时应显式说明所用类型转换方法 常用于将类类型转换成基本类型，通常自动隐式调用，当有二义性时，必须显式调用 在一个类中，可以定义多个类类型转换成员函数 其功能与转换构造函数(单参数构函)互逆 可看做类型转换运算符的重载# include iostream.hclass Apublic: A(int i, int j)x=i; y=j; operator double()return double(x)/double(y);private: int x, y;void main()A a(3,4); double m=2.5, n=0.125;

48、 m+=a-n; coutmendl;结果：3.125# include iostream.hclass Apublic: A(int i, int j):x(i), y(j) operator int() coutxyoperatorn; return x+y;private: int x, y;void main() A a(2,3),b(4,5), c(6,7); int k=9; k=a+b-k+c; coutkendl;结果：23operator45operator67operator18# include iostream.hclass Apublic: A(int i=0)x=i

49、; void show()coutxendl; operator int()coutxoperatorn; return x;private: int x;void main() A m(3), n(4); int j=5, k=6; coutm+k-j+nendl; cout(m=k+j-n)endl; A(m+k+j+n).show(); A(k=m-n).show(); (m=n+j).show();结果：3operator4operator84operator7operator77 operator4 operator227 operator4 operator34 operator9

50、# include iostream.hclass Apublic: A(int i=0)x=i; coutxConAn; A()coutDesAxendl; void show()coutxendl; operator int()coutxoperatorn; return x;private: int x;void main()A m(3), n(4); int k=6; k=m+n; coutkendl; n=k+m; n.show();结果：3ConA4ConA3operator4operator73operator10ConADesA1010DesA10DesA3# include

51、iostream.hclass Apublic: A(int i, int j)x=i; y=j; operator int() coutxyoperator intn; return x+y; operator double() coutxyoperator doublen;return double(x)/double(y);private: int x, y;void main()A a(3,4), b(2,5); int k; double d; k=int(a)+int(b); coutkendl; d=double(a)-double(b)+int(b);coutdendl;结果：

52、34operator int25operator int1434operator double25operator double25operator int7.35# include iostream.hclass Apublic: A(int i=0)x=i; operator int()return x+1; void show()coutxAn;private: int x;class Bpublic: B (int j=0)y=j; operator int()return y; void show()coutyBn;private: int y;void main()A a(3),

53、b(4); B m(5), n(6);a=m+n; a.show(); /a=A(int(m)+int(n)m=a-b; m.show(); /m=B(int(a)-int(b)n=int(b); n.show(); /n=B(int(b)a=A(m); a.show(); /a=A(int(m)结果：11A7B5B7A# include iostream.hclass Apublic: A(int i=0)x=i; void show()coutxAn; int g()return x;private: int x;class Bpublic: B(A & p)y=p.g()+1; oper

54、ator A()return A(y+2);private: int y;void main()A a(3), b(4); B m=a, n(b); a=n; a.show(); b=m; b.show();结果：7A6A# include iostream.hclass Apublic: A(int i, double j)x=i; y=j; operator int()return x*x; operator double()return x+y;private: int x; double y;void main()A a(3,4.5); int b=a; double d=a; cou

55、tbdendl; coutint(a)double(a)endl; couta.operator int()a.operator double()endl;结果：97.597.597.5310 友元数据共享：增加了程序模块间的耦合度全局量：可实现函数间的数据共享数据成员：可实现对象内成员函数间的数据共享静态数据成员：可实现同类对象间的数据共享友元：可实现类与类之间的数据共享友元： 提供了在不同类的成员函数之间，类的成员函数与一般全局函数之间进行数据共享的机制 使非本类成员函数可以直接访问本类中的私有和保护成员 它破坏了类的封装性和数据隐藏性，应慎用 它可提高程序的运行效率 它可以是函数，称为友

56、元函数 它也可以是一个类，称为友元类 它必须在类体中声明，其前加friend 友元函数中无this指针 友元不受访问权属段（访问权限修饰符）的制约 友元关系不可逆，也不可传递和继承 友元可在类定义的任意位置声明，但为醒目，常放于类定义首部的公有段开头一、友元函数 可以是一个普通函数，也可以是其他类的成员函数 是由friend修饰的非本类成员函数 声明：friend 类型符 函数名(参数表);或friend 类型符 类名 : 函数名(参数表);# include iostream.h# include math.hclass Pointpublic: Point(double i, double

57、 j)x=i; y=j; void show()coutx,yendl; friend double distance(Point a, Point b); friend Point middle(Point m, Point n) return Point(m.x+n.x)/2, (m.y+n.y)/2;private: double x, y;double distance (Point a, Point b) double dx=a.x-b.x; double dy=a.y-b.y; return sqrt(dx*dx+dy*dy); void main() Point p1(6,8),

58、 p2(3,4); coutdistance(p1,p2)endl; middle(p1,p2).show();结果：54.5, 6# include iostream.hclass B;class Apublic: A(int i, int j)x=i; y=j; void show()coutx,yendl; friend void f(A a, B b);private: int x, y;class Bpublic: B(int k):z(k) void show()coutzendl; friend void f(A a, B b);private: int z;void f(A a

59、, B b)b.z=a.x+a.y-b.z; a.x=b.z+a.y-a.x; a.y=b.z+a.x-a.y; a.show(); b.show();void main()A m(3,7); B n(2); f(m, n); m.show(); n.show();结果：12, 1383, 72# include iostream.hclass B;class Apublic: A(int i, int j)x=i;y=j; void show(B c); void f(B & b);private: int x, y;class Bpublic: B(int k)z=k; void show

60、()coutzendl; friend void A:show(B c); friend void A:f(B & b);private: int z;void A:f(B & b)b.show(); b.z=x+y;void A:show(B c) coutx,yendlc.zendl;void main()A m(3,4); B n(5); m.f(n); m.show(n);结果：53,47# include iostream.hclass B;class Apublic: A(int i, int j)x=i;y=j; friend void show(A a, B b); void