为了达到不通过对象就能访问静态成员的目的。

详细请看转载来自：https://blog.csdn.net/qq_37375427/article/details/78808900

我们回顾一下客户的需求：

统计在程序运行期间某个类的对象的数目
保证程序的安全性（不能使用全局变量）
随时可以获取当前对象的数目（完成了么？）
看当时的代码：

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...");
1
对象调用静态成员函数：

d.StaticSetI(d, 20);
1
可以看出静态成员函数的性质大体如下：

静态成员函数是类中特殊的成员函数
静态成员函数属于整个类所有
可以通过类名（作用域访问）直接访问公有静态成员函数
可以通过对象名访问公有静态成员函数
而且通过这段代码：

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指针
静态成员函数可以通过类名直接访问
静态成员函数可以通过对象访问
静态成员函数只能直接访问静态成员变量（函数），而不能直接访问普通成员变量（函数）