C++中类的(static)静态成员变量与(static)静态成员函数

转自：https://blog.csdn.net/lms1008611/article/details/81408236?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_baidulandingword-2&spm=1001.2101.3001.4242

    在C语言中，我们知道有static静态变量，生命周期与作用域都跟普通变量有所不同。而在C++的类中，也有静态成员变量同时还有静态成员函数，先来看看C++中静态成员变量与静态成员函数的语法：

  1.  
    #include <iostream>
  2.  
    #include <string>
  3.  
     
  4.  
    using namespace std;
  5.  
     
  6.  
    class test
  7.  
    {
  8.  
    private:
  9.  
    static int m_value; //定义类的静态成员变量
  10.  
     
  11.  
    public:
  12.  
     
  13.  
    static int getValue() //定义类的静态成员函数
  14.  
    {
  15.  
    return m_value;
  16.  
    }
  17.  
    };
  18.  
     
  19.  
    int test::m_value = 12; //类的静态成员变量需要在类外分配内存空间
  20.  
     
  21.  
    int main()
  22.  
    {
  23.  
    test t;
  24.  
     
  25.  
    cout << t.getValue() << endl;
  26.  
    system("pause");
  27.  
    }

以上代码，我们在test类中分别定义了一个静态成员变量与静态成员函数，首先来看下静态成员变量
    -静态成员变量属于整个类所有
    -静态成员变量的生命期不依赖于任何对象，为程序的生命周期
    -可以通过类名直接访问公有静态成员变量
    -所有对象共享类的静态成员变量
    -可以通过对象名访问公有静态成员变量
    -静态成员变量需要在类外单独分配空间
    -静态成员变量在程序内部位于全局数据区 (Type className::VarName = value)

针对静态成员变量的以上几点，我们把上边的代码修改如下，用于统计当前对象的个数:
 

  1.  
    #include <iostream>
  2.  
    #include <string>
  3.  
     
  4.  
    using namespace std;
  5.  
     
  6.  
    class test
  7.  
    {
  8.  
    private:
  9.  
    static int m_value1; //定义私有类的静态成员变量
  10.  
    public:
  11.  
    static int m_value2; //定义私有类的静态成员变量
  12.  
     
  13.  
    public:
  14.  
    test()
  15.  
    {
  16.  
    m_value1++;
  17.  
    m_value2++;
  18.  
    }
  19.  
     
  20.  
    int getValue() //定义类的静态成员函数
  21.  
    {
  22.  
    return m_value1;
  23.  
    }
  24.  
    };
  25.  
     
  26.  
    int test::m_value1 = 0; //类的静态成员变量需要在类外分配内存空间
  27.  
    int test::m_value2 = 0; //类的静态成员变量需要在类外分配内存空间
  28.  
     
  29.  
    int main()
  30.  
    {
  31.  
    test t1;
  32.  
    test t2;
  33.  
    test t3;
  34.  
     
  35.  
    cout << "test::m_value2 = " << test::m_value2 << endl; //通过类名直接调用公有静态成员变量，获取对象个数
  36.  
    cout << "t3.m_value2 = " << t3.m_value2 << endl; //通过对象名名直接调用公有静态成员变量，获取对象个数
  37.  
    cout << "t3.getValue() = " << t3.getValue() << endl; //通过对象名调用普通函数获取对象个数
  38.  
    system("pause");
  39.  
    }

编译输出:

从输出，貌似得到我们想要的效果，但是C++中讲究的是封装性，以上代码，有2个不妥之处
   1、类名或对象名能直接访问成员变量，也就是说成员变量能直接被外界修改
   2、我们使用了一个成员函数来获取当前的对象个数，看似没问题，但是必须要定义对象，通过对象去调用，但有时候我们不想定义对象，也能使用类中的成员函数，这就是我们要说的类的静态成员函数。

类的成员函数有如下特性:
    -静态成员函数是类的一个特殊的成员函数
    -静态成员函数属于整个类所有，没有this指针
    -静态成员函数只能直接访问静态成员变量和静态成员函数
    -可以通过类名直接访问类的公有静态成员函数
    -可以通过对象名访问类的公有静态成员函数
    -定义静态成员函数，直接使用static关键字修饰即可

现在我们再来修改上边的代码
 

  1.  
    #include <iostream>
  2.  
    #include <string>
  3.  
     
  4.  
    using namespace std;
  5.  
     
  6.  
    class test
  7.  
    {
  8.  
    private:
  9.  
    static int m_value; //定义私有类的静态成员变量
  10.  
     
  11.  
    public:
  12.  
    test()
  13.  
    {
  14.  
    m_value++;
  15.  
    }
  16.  
     
  17.  
    static int getValue() //定义类的静态成员函数
  18.  
    {
  19.  
    return m_value;
  20.  
    }
  21.  
    };
  22.  
     
  23.  
    int test::m_value = 0; //类的静态成员变量需要在类外分配内存空间
  24.  
     
  25.  
    int main()
  26.  
    {
  27.  
    test t1;
  28.  
    test t2;
  29.  
    test t3;
  30.  
     
  31.  
    cout << "test::m_value2 = " << test::getValue() << endl; //通过类名直接调用公有静态成员函数，获取对象个数
  32.  
    cout << "t3.getValue() = " << t3.getValue() << endl; //通过对象名调用静态成员函数获取对象个数
  33.  
    system("pause");
  34.  
    }

编译输出:

这样我们就直接能通过类名去访问静态成员函数，获取对象个数，不通过任何对象。

静态成员函数在C++中的作用很强大，包括后边的介绍的单例模式、二阶构造模式，都用到静态成员函数及静态成员变量。

下边的图为静态成员函数与普通成员函数的比较