【C++深度剖析教程5】C++中类的静态成员函数

学习交流加（可免费帮忙下载CSDN资源）：

个人微信： liu1126137994

学习交流资源分享qq群1（已满）： 962535112

学习交流资源分享qq群2： 780902027

在上一篇文章中我们讲了C++中类的静态成员变量，用类的静态成员变量实现了统计程序运行期间的某个类的对象的数目（不清楚的可以点击连接查看上一篇文章 C++中类的静态成员变量）。

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

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

看当时的代码：

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

想获得各种学习资源以及交流学习的加我：
qq：1126137994
微信：liu1126137994
可以共同交流关于嵌入式，操作系统，C++语言，C语言，数据结构等技术问题！