静态成员函数

除静态数据成员外，C++也允许定义static成员函数。静态的数据成员被所有的对象共享，也就是说，静态数据成员不属于对象，而是属于类的。与静态数据成员类似，静态成员函数也是属于类的。
　　 注意：静态成员函数仅能访问静态的数据成员，不能访问非静态的数据成员，也不能访问非静态的成员函数，这是由于静态的成员函数没有this指针。类似于静态的数据成员，公有的、静态的成员函数在类外的调用方式为：
　　 类名::成员函数名(实参表)
不过,也允许用对象调用静态的成员函数。
下面举一个例子说明静态成员函数的调用方法:
例10-9
class Directory
{
　 public:
　　 ...
　　 // 静态公有的函数
　　 static void setpath(char const *newpath);

　private:
　　 // 静态字符串
　　 static char path [];
};

//静态数据成员的初始化
char Directory::path [199] = "/usr/local";

// 静态函数
void Directory::setpath(char const *newpath)
{
　 strncpy(path, newpath, 199);
}

// 使用实例
void main()
{
　 // 通过类名调用setpath()成员函数
　 Directory::setpath("/etc");

　//通过象调用setpath()成员函数
　 Directory dir;
　 dir.setpath("/etc");
}
　　 在上面的例子中, setpath()始一个公有静态的成员函数，C++也允许私有静态的成员函数，它只能被该类的其它成员函数调用，不能在类外被调用。
　　 需要注意的是：静态的成员函数仅能访问静态的变量和静态的成员函数，不能访问非静态的数据成员和非静态的成员函数。
　　我们也可以创建一个静态的成员函数。同静态数据成员类似，它也是属于类，而不是属于某一个对象的。
　　 静态成员函数不能访问非静态的数据成员，它只能访问静态数据成员，也只能调用其它的静态成员函数。原因是：当前对象的地址（this）是被隐含地传递到被调用的函数的。但一个静态成员函数没有this指针，所以它无法访问非静态的成员函数。
　　 下面是一个应用静态数据成员和静态成员函数的例子：
例10-10
class X
{
　 int i;
　 static int j;
public:
　 X(int I = 0):i(I)
　 {
　　 //非静态成员函数可以访问
　　 //静态成员变量和成员函数
　　 j = i;
　 }

　int val()const
　 {
　　 return i;
　 }

　static int incr()
　 {
　　 //i++;　　　//Error: 静态成员函数
　　　　　　　　 //不能访问非静态成员变量
　　 return ++j; //OK
　 }

　static int f()
　 {
　　 //val(); 　　　//Error: 静态成员函数
　　　　　　　　　　 //不能访问非静态成员函数
　　 return incr(); //OK
　 }
};

int X::j = 0;

void main()
{
　 X x;
　 X* pX = &x;
　 x.f();
　 pX -> f();
　 X::f();
}
　　 由于静态成员函数是属于类的，所以，静态成员函数的调用方法为：
　　 类名::静态成员函数名();
但也允许用对象或指向对象的指针调用。例如，在main()中，静态成员函数f分别被对象x和指向x对象的指针pX调用。
　　下面是一个有趣的例子：类egg有一个静态数据成员E和静态成员函数instance，instance的返回类型是指向egg对象的指针，类的构造函数是私有的。显然，我们不能创建该类的对象。但是该类确有一个对象存在，我们可以访问那个对象，也可以通过该对象访问其成员函数：
例10-11
#include <iostream.h>
class egg
{
　 static egg E;
　 int i;
　 egg(int I):i(I){}
public:
　 static egg* instance()
　 {
　　 return &E;
　 }
　 int val()
　 {
　　 return i;
　 }
};

egg egg::E(100);

void main()
{
　 //egg x(1); //Error: 不能调用私有的构造函数
　 //因此，不能创建新的对象
　 cout<<egg::instance()->val()<<endl;
}
　　 E 的初始化出现在类的声明完成后，所以编译器已有足够的信息为对象分配空间并调用构造函数。