回顾一下客户的需求：
-统计在程序运行期间某个类的对象的数目
-保证程序的安全性（不能使用全局变量）
-随时可以获取当前对象的数目（完成了么？）
看当时的代码：
#include <stdio.h>
class Test
{
private:
static int cCount;
public:
Test()
{
cCount++;
}
~Test()
{
--cCount;
}
int getCount()
{
return cCount;
}
};
int Test::cCount = 0;
Test gTest;
int main()
{
Test t1;
Test t2;
printf("count = %d\n", gTest.getCount());
printf("count = %d\n", t1.getCount());
printf("count = %d\n", t2.getCount());
Test* pt = new Test();
printf("count = %d\n", pt->getCount());
delete pt;
printf("count = %d\n", gTest.getCount());
return 0;
}很明显，我们获取对象的数目是需要调用getCount这个函数，每次调用都需要某一个对象来调用，比如：gTest.getCount()，那么问题来了，如果整个程序的对象的个数为0呢？那么岂不是没法调用getCount这个函数，也就没法知道对象的个数（别人是不知道你的对象的个数为0的）？
可不可以这样呢？我把静态成员变量cCount变为public，然后直接让Test（作用域调用）这个类来调用？先上一波代码看看：
#include <stdio.h>
class Test
{
public:
static int cCount;
public:
Test()
{
cCount++;
}
~Test()
{
--cCount;
}
int getCount()
{
return cCount;
}
};
int Test::cCount = 0;
int main()
{
printf("count = %d\n", Test::cCount);
//Test::cCount = 1000;
//printf("count = %d\n", Test::cCount);
return 0;
}此代码与上面的代码的不同的是cCount变量变为public便于Test（作用域访问）类调用，没有任何的对象了，那么编译运行，输出结果应该是：
count = 0
说明这样做，符合了我们的需求了。但是，不要高兴的太早了，我们这样真的可以么？加入我把代码中的被注释的那两行加上（下面这两行）：
Test::cCount = 1000;
printf("count = %d\n", Test::cCount);再次运行会发生什么呢？我们编译运行，结果输出为：
count = 0
count = 1000
那么多问题来了，客户现在懵逼了，他会以为对象的个数有1000个，所以，这也是一个大的Bug啊，从本上讲，这样做也是无法满足客户的需求的，而且将cCount变为public，本身就是无法保证静态成员变量的安全性，我们需要什么？
*不依赖对象就可以访问静态成员变量
*必须保证静态成员变量的安全性
*方便快捷得获取静态成员变量的值
那么静态成员函数就要出马了：
静态成员函数的定义：
直接通过static关键字修饰成员函数即可
为了便于理解，我们先上一段代码来理解一下静态成员函数的性质：
#include <stdio.h>
class Demo
{
private:
int i;
public:
int getI();
static void StaticFunc(const char* s);
static void StaticSetI(Demo& d, int v);
};
int Demo::getI()
{
return i;
}
void Demo::StaticFunc(const char* s)
{
printf("StaticFunc: %s\n", s);
}
void Demo::StaticSetI(Demo& d, int v)
{
d.i = v;
}
int main()
{
Demo::StaticFunc("main Begin...");
Demo d;
d.StaticSetI(d, 20);
printf("d.i = %d\n", d.getI());
Demo::StaticSetI(d, 10);
printf("d.i = %d\n", d.getI());
Demo::StaticFunc("main End...");
return 0;
}以上代码运行的结果为：
StaticFunc: main Begin…
d.i = 20
d.i = 10
StaticFunc: main End…
由代码看到两个静态成员函数：
static void StaticFunc(const char* s);
static void StaticSetI(Demo& d, int v);类调用静态成员函数：
Demo::StaticFunc("main Begin...");对象调用静态成员函数：
d.StaticSetI(d, 20);可以看出静态成员函数的性质大体如下：
*静态成员函数是类中特殊的成员函数
*静态成员函数属于整个类所有
*可以通过类名（作用域访问）直接访问公有静态成员函数
*可以通过对象名访问公有静态成员函数
而且通过这段代码：
void Demo::StaticSetI(Demo& d, int v)
{
d.i = v;
}我么可以看出，静态成员函数，没有直接调用变量i，而是通过对象来间接调用变量i，这说明什么呢？说明：静态成员函数不能访问普通成员变量（函数），需通过对象间接访问成员变量（函数）
下面做一个表格来对比一下静态成员函数与普通成员函数的区别：
好了，理解了静态成员函数，我们也应该来解决客户的需求了吧：直接上代码：
#include <stdio.h>
class Test
{
private:
static int cCount;
public:
Test()
{
cCount++;
}
~Test()
{
--cCount;
}
static int GetCount()
{
return cCount;
}
};
int Test::cCount = 0;
int main()
{
printf("count = %d\n", Test::GetCount());
Test t1;
Test t2;
printf("count = %d\n", t1.GetCount());
printf("count = %d\n", t2.GetCount());
Test* pt = new Test();
printf("count = %d\n", pt->GetCount());
delete pt;
printf("count = %d\n", Test::GetCount());
return 0;
}
运行结果为：
count = 0
count = 2
count = 2
count = 3
count = 2
分析： printf("count = %d\n", Test::GetCount());这段代码运行之前，没有创建对象，所以count = 0，
printf("count = %d\n", t1.GetCount());
printf("count = %d\n", t2.GetCount());这两段代码运行之前已经创建了t1，t2这两个对象，所以都为：count = 2，
printf("count = %d\n", pt->GetCount());这个运行之前又在堆空间创建了一个对象，并且让pt指针指向它，所以：count = 3
delete pt;
printf("count = %d\n", Test::GetCount());在这两行先将pt指向的对象删除，所以最后是：count = 2
问题终于解决了！！！
总结：
-静态成员函数是类中的特殊的成员函数
-静态成员函数没有隐藏的this指针
-静态成员函数可以通过类名直接访问
-静态成员函数可以通过对象访问
-静态成员函数只能直接访问静态成员变量（函数），而不能直接访问普通成员变量（函数）