第十二章静态友元

注意：静态成员函数与非静态成员函数的根本区别在于静 态成员函数没有this 指针，而非静态成员函数有一个隐含的指 向当前对象的this 指针。 例如：该例说明一个静态成员函数与任何当前对象都无联 系的原因 class Sc { public: void nsfn(int a); //类似于Sc::nsfn(Sc *this, int a); static void sfn(int a); //无this 指针 //…… } void fc(Sc& s) { s.nsfn(10); //转换为Sc::nsfn(&s,10); s.sfn(10); //转变为Sc::sfn(10); }
static float average( ) { return totalscore/count; } private: float computerscore; static float totalscore; static float averagescore; static int count; } float Student::totalscore=0; float Student::averagescor=0; float Student::count=0;
结果： A=6，B=24 A=8，B=24
//类名调用 //对象调用
例如：下面是另一个程序例子
#include <iostream.h> enum access_t {shared, in_used, locked, unlocked}; class access { public: static void set_access(access_t a) { acs=a; } static access_t get_access() { return(acs); } private: static access_t acs; };
静态数据使用关键字static，静态数据成员在类体中说明， 在类体外定义，以分配存储空间并初始化。
例如：下面例子说明了静态数据的说明和初始化方法。 #include <iostream.h> #include <stdio.h> class counter { static int count; //在类体内说明静态数据 public: void setcount(int i) { count=i; } void showcount() { cout<<count; } } int counter::count=0; //在类体外定义静态数据 void main() { counter a,b;
access_t access::acs=0; void main() { access obj1,obj2; obj1.set_access(unlocked); if(obj2.get_access()==unlocked) { obj2.set_access(in_used); cout<<“access resource\n”; } else cout<<“locked out\n”; } 输出为：access resource
第十二章
目
录
§12.1
§12.2 §12.3
静态数据
静态成员函数 友元
第十二章小结
第十二章 静态成员与友元
全局对象是实现数据共享的一种方法，由于它处处可见， 因此不够安全，应尽量在程序中少用全局对象。
实现类的多个对象之间的数据共享，可使用静态成员。
静态成员包括静态数据成员和静态成员函数。 友元函数也是一种普通的C++ 函数，但是它可以访问类 的保护或私有成员，方便编程，提高了效率，同时也破坏了 类的封装性。 本章内容：介绍如何使用静态数据成员和静态成员函数， 了解友元的使用方法及作用的局限性。
§12.3 友元(Friends)
类具有封装性，类中的私有数据只有通过该类的成员函数 才可以访问。如果在程序中需要访问类的私有成员，就必须通 过对象来调用类的成员函数，频繁调用成员函数将影响程序运 行效率。
为解决上述问题，C++ 提供一种友元机制，友元可以不通 过调用成员函数就可以直接访问类的私有数据，以提高程序运 行效率。 友元机制在数据封装这堵不透明的墙上开了一个小孔，友 元的使用要慎重。
void func(X *ptr, int a) { ptr->i=a; } void X::member_func(int a) { i=a; }
对静态成员函数的访问，在程序中可使用如下方式：
<类名>::<静态成员函数名>(<参数表>)
或 <对象名>.<静态成员函数名>(<参数表>) 静态成员函数只属于一个类，而不属于类中的任何对象。
例如：下面是定义和使用静态成员函数的例子 #include <iostream.h> class M { public: M(int a) { A=a; B+=a; } static void fun(M m); //说明静态成员函数 private: int A; static int B; }
void main() { Myclass M(3,4,5),N(5,6,7); N.getnumber(); cout<<M.getsum(M)<<“;”<<M.getsum(N)<<endl; } 结果： 5; 6; 7 30; 30 注意：在成员函数getsum()中，通过类来使用静态数据成员sum， 如：return Myclass::sum; 也可以通过对象来使用sum，如：return m.sum;
在一个类中，若将一个数据说明为static，则该数据称为静 态数据，它告诉编译器无论建立多少个该类的对象，都只有一 个静态数据的拷贝，这个拷贝被所有类对象共享。 静态数据属于类而共享，不属于对象独有。它的值对每个 对象都是一样的。
对静态数据成员的值的更新，即是对所有对象的该静态数 据成员值的更新。
§12.1 静态数据
A variable that is part of a class, yet is not part of an object of that class, is called a static member. There is exactly one copy of a static member instead of one copy per object, as for ordinary non-static members.
例: Class Student { public: Student( ) {computerscore=0;} Student(float score) { computerscore=score; totalscore+=score; count++; } static float totalsum( ) { return totalscore; }
例如：下面程序说明了静态数据成员的定义、初始化和使用的 方法。
#include <iostream.h> class Myclass { public: Myclass(int a,int b,int c); void getnumber( ); int getsum(Myclass m); private: int A,B,C; static int sum; }; int Myclass::sum(0);
void M::fun(M m) //定义静态成员函数 { cout<<“A=”<<m.A<<“，”; //通过对象访问非静态变量 cout<<“B=”<<B<<endl; //直接访问静态变量 } int M::B=10; //定义并初始化静态变量
void main() { M P(6),q(8); M::fun(P); q.fun(q); }
a.showcount(); b.showcount(); a.setcount(10); a.showcount(); b.showcount(); }
结果： 0 0 10 10
从例子中可见，定义静态数据成员时，可根据需要说明其 访问权限控制符。 静态数据成员的生命期是全局的，编译器只对它进行一次 初始化，将始终保持其值，直到下次改变为止。
Myclass::Myclass(int a,int b,int c) { A=a; B=b; C=c; sum+=A+B+C; }
void Myclass::getnumber(); { cout<<A<<“;”<<B<<“;”<<C<<endl; }
int Myclass::getsum(Myclass m) { return Myclass::sum; }
§12.1 静态成员函数(Static member function)
A function that needs access to members of a class, yet does not need to be invoked for a particular object, is called a static member function. 静态成员函数的说明和定义与静态数据成员一样，函数实 现可在类体内，也可在类体外，与一般成员函数相同。 在静态成员函数的实现中，可以直接使用静态成员，可以 通过对象来使用非静态成员。
友元可以是一个函数，称为友元函数；友元可以是一个类， 称为友元类。
一、友元函数 An ordinary member function declaration specifies three logically distinct things: 1、The function can access the private part of the class declaration and 2、the function is in the scope of the class and 3、the function must be invoked on an object (has a this pointer). By declaring a member function static we can give it the first two properties only. By declaring a function a friend, we can give it the first property only.
void main( ) {Student sd1(92),sd2(85),sd3(80); cout<<sd1.totalsum( )<<endl; cout<<sd2.average( )<<endl; cout<<sd3.average( )<<endl; }
运行结果:
257 85.66 85.66
下图形象地说明了一个类Group 的四个对象的存储分配情 况，每个对象具有自己的字符变量ch 的拷贝内存空间，而共享 静态型变量s，即静态变量s 在存储上只需拷贝一处就可以供所 有对象使用。 Group c class Group { char ch;
char ch; static int s;
}
友元函数具有下述特点： 1、在类体内说明，在函数的类型说明符前加关键字friend；
2、在类体外定义，定义格式与普通函数相同；
3、友元函数是非成员函数，在调用上与普通函数相同； 4、友元函数可以直接访问该类中的私有成员。 例如：下面程序段说明友元函数的说明和定义方法 class X { int i; friend void func(X *, int); //friend function declaration public void member_func(int); };
Group a char ch;
Group b
static int s;
char ch;
Fra Baidu bibliotek
Group d char ch;
静态数据成员可应用在以下几个方面： (1) 用来保存流动变化的对象个数(如学生人数)； (2) 作为一个标志，指示一个特定的动作是否发生； (3) 指向一个链表的第一成员或最后一个成员的指针。