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 = ;

 int main()
 {
     printf("count = %d\n", Test::cCount);  // 打印 0；

     Test::cCount = ;

     printf("count = %d\n", Test::cCount);  // 打印 1000；

     return ;
 }

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 ;
 }

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\n", 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, );   // 通过变量名调用静态成员函数

     printf("d.i = %d\n", d.getI());  // 打印 1；和不同成员变量使用方法一样；

     Demo::StaticSetI(d, );  // 通过类名调用静态成员函数；

     printf("d.i = %d\n", d.getI());  // 打印 10；

     Demo::StaticFunc("main End...");

     return ;
 }

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 = ;

 int main()
 {
     printf("count = %d\n", Test::GetCount());  // 打印 0；

     Test t1;
     Test t2;

     printf("count = %d\n", t1.GetCount());  // 打印 2；
     printf("count = %d\n", t2.GetCount());  // 打印 2；

     Test* pt = new Test();

     printf("count = %d\n", pt->GetCount());  // 打印 3；

     delete pt;

     printf("count = %d\n", Test::GetCount());  // 打印 2；

     return ;
 }

9，小结：

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

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

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

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

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