C++中的静态成员函数

1，问完成的需求：

    1，统计在程序运行期间某个类的对象数目；

       1，静态成员变量满足了这个需求；

    2，保证程序的安全性（不能使用全局变量）；

    3，随时可以获取当前对象的数目；

       1，有没有什么特别的地方或边界点没有考虑到呢？

   

2，解决方案的尝试编程实验：

#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
", Test::cCount);  // 打印 0；
    
    Test::cCount = 1000;
    
    printf("count = %d
", Test::cCount);  // 打印 1000；
    
    return 0;
}

    1，当没有定义对象时候，应该打印 0，而这里不能满足，完全没办法打印，因     为必须要对象才可以调用打印结果；

    2，共有静态成员变量可以解决临界问题，但是不安全，会被误操作；

   

3，问题分析：我们需要什么？

    1，不依赖对象就可以访问静态成员变量；

    2，必须保证静态成员变量的安全性；

    3，方便快捷的获取静态成员变量的值；

   

4，静态成员函数：

    1，在 C++ 中可以定义静态成员函数：

       1，静态成员函数是类中特殊的成员函数；

       2，静态成员函数隶属于整个类所有；

       3，可以通过类名直接访问公有静态成员函数；

       4，可以通过对象名访问公有静态成员函数；

      

5，静态成员函数的定义：

    1，直接通过 static 关键字修饰成员函数：

    2，代码示例：

class Test
 2 {
public:
　　static void Func1() {}
　　static int Func2();
};

int Test::Func2() 
{
　　return 0;
}

6，静态成员函数示例编程实验：

#include <stdio.h>

class Demo
{
private:
    int i;
    
public:
    int getI();
    static void StaticFunc(const char* s);
    static void StaticSetI(Demo& d, int v);
    // static void StaticSetI(int v);
};

int Demo::getI()
{
    return i;
}

void Demo::StaticFunc(const char* s)
{
    printf("StaticFunc: %s
", s);
}

void Demo::StaticSetI(Demo& d, int v)
{
    d.i = v;  // 这是通过对象名访问，没有直接访问成员变量；
}

/*
void Demo::StaticSetI(int v)
{
    i = v;  // 编译器显示，在静态成员变量中不能访问成员变量 i；因为静态成员函数不可以直接访问成员变量，访问成员变量需要 this 指针的指向，而这里静态成员函数没有 this 指针；
}
*/

int main()
{
    Demo::StaticFunc("main Begin...");
    
    Demo d;
    
    d.StaticSetI(d, 1);   // 通过变量名调用静态成员函数
    
    printf("d.i = %d
", d.getI());  // 打印 1；和不同成员变量使用方法一样；
    
    Demo::StaticSetI(d, 10);  // 通过类名调用静态成员函数；
    
    printf("d.i = %d
", d.getI());  // 打印 10；
    
    Demo::StaticFunc("main End...");
    
    return 0;
}

   

7，静态成员函数 vs 普通成员函数：

    1，可以通过对象名调用静态成员函数；

    2，不能访问普通成员变量和成员函数，因为没有 this 指针；

    3，静态成员函数存放在代码段，可以供对象和成员函数调用；

   

8，最后的解决方案编程实验：

#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
", Test::GetCount());  // 打印 0；
    
    Test t1;
    Test t2;
    
    printf("count = %d
", t1.GetCount());  // 打印 2；
    printf("count = %d
", t2.GetCount());  // 打印 2；
    
    Test* pt = new Test();
    
    printf("count = %d
", pt->GetCount());  // 打印 3；
    
    delete pt;
    
    printf("count = %d
", Test::GetCount());  // 打印 2；
    
    return 0;
}

   

9，小结：

    1，静态成员函数是类中特殊的成员函数；

    2，静态成员函数没有隐藏的 this 参数；

       1，因此不能访问普通的成员函数及普通的成员变量；

    3，静态成员函数可以通过类名直接访问；

    4，静态成员函数只能直接访问静态成员变量（函数）；