C++ static变量 static函数

  static 变量静态变量属于静态存储方式，其存储空间为内存中的静态数据区（在静态存储区内分配存储单元），该区域中的数据在整个程序的运行期间一直占用这些存储空间（在程序整个运行期间都不释放），也可以认为是其内存地址不变，直到整个程序运行结束（相反，而auto自动变量，即动态局部变量，属于动态存储类别，占动态存储空间，函数调用结束后即释放）。静态变量虽在程序的整个执行过程中始终存在，但是在它作用域之外不能使用。
　　另外，属于静态存储方式的量不一定就是静态变量。 例如：外部变量虽属于静态存储方式，但不一定是静态变量，必须由 static加以定义后才能成为静态外部变量，或称静态全局变量。
　　所有的全局变量都是静态变量，而局部变量只有定义时加上类型修饰符static，才为局部静态变量。
　　静态变量可以在任何可以申请的地方申请，一旦申请成功后，它将不再接受其他的同样申请。
　　静态变量并不是说其就不能改变值，不能改变值的量叫常量。 其拥有的值是可变的，而且它会保持最新的值。说其静态，是因为它不会随着函数的调用和退出而发生变化。即上次调用函数的时候，如果我们给静态变量赋予某个值的话，下次函数调用时，这个值保持不变。

--------------------------------------------------------------------------------

　1. 静态局部变    Static类内部变量同auto自动变量（即未加 Static 声明的局部变量）一样，是某个特定函数的局部变量，即只能在定义该变量的函数内使用该变量，2者作用域相同；两者的不同在于：auto自动变量会随着函数被调用和退出而存在和消失，而static类局部变量不会，它不管其所在的函数是否被调用，都将一直存在；不过，尽管该变量还继续存在，但不能使用它。倘若再次调用定义它的函数时，它又可继续使用，而且保存了前次被调用后留下的值。换言之，Static类型的内部变量是一种只能在某个特定函数中使用，但一直占据存储空间的变量。

2、函数体内如果在定义静态变量的同时进行了初始化，则以后程序不再进行初始化操作（出现在函数内部的基本类型的的静态变量初始化语句只有在第一次调用才执行）。而对自动变量赋初值是在函数调用时进行，每调用一次函数重新给一次初值，相当于执行一次赋值语句。

3、静态局部变量的初始化表达式必须是一个常量或者常量表达式。即使局部静态变量定义时没有赋初值，系统会自动赋初值0（对数值型变量）或空字符（对字符变量）；静态变量的初始值为0。而对自动变量auto来说，如果不赋初值则它的值将是个不确定的值。

  4、当多次调用一个函数且要求在调用之间保留某些变量的值时，可考虑采用静态局部变量。虽然用全局变量也可以达到上述目的，但全局变量有时会造成意外的副作用，因此仍以采用局部静态变量为宜。

例：

/

#include  <iostream> 
using namespace std; 
void staticLocalVar() 
{ 
 static int a = 0; // 运行期时初始化一次, 下次再调用时, 不进行初始化工作 
 cout < <"a=" < <a < <endl; 
 ++a; 
} 

int main() 
{ 
 staticLocalVar(); // 第一次调用, 输出a=0 
 staticLocalVar(); // 第二次调用, 记忆了第一次退出时的值, 输出a=1 
 return 0; 
} 

///

static函数

  为了限制全局变量/函数的作用域, 函数或变量前加static使得函数成为静态函数。但此处“static”的含义不是指存储方式，而是指对函数的作用域仅局限于本文件(所以又称内部函数)。注意此时, 对于外部(全局)变量, 不论是否有static限制, 它的存储区域都是在静态存储区, 生存期都是全局的. 此时的static只是起作用域限制作用, 限定作用域在本模块(文件)内部。

————————————————————————————————

//file1.cpp 

static int varA; 
int varB; 
extern void funA() 
{ 
…… 
} 

static void funB() 
{ 
…… 
} 

//file2.cpp 

extern int varB; // 使用file1.cpp中定义的全局变量 
extern int varA; // 错误! varA是static类型, 无法在其他文件中使用 
extern vod funA(); // 使用file1.cpp中定义的函数 
extern void funB(); // 错误! 无法使用file1.cpp文件中static函数 

————————————————————————————————————

静态数据成员／成员函数

 C++重用了这个关键字，并赋予它与前面不同的第三种含义：表示属于一个类而不是属于此类的任何特定对象的变量和函数.

 这是与普通成员函数的最大区别, 也是其应用所在,

 比如在对某一个类的对象进行计数时, 计数生成多少个类的实例, 就可以用到静态数据成员. 

在这里面, static既不是限定作用域的, 也不是扩展生存期的作用, 而是指示变量/函数在此类中的唯一性.

 这也是”属于一个类而不是属于此类的任何特定对象的变量和函数”的含义.

 因为它是对整个类来说是唯一的, 因此不可能属于某一个实例对象的. 

(针对静态数据成员而言, 成员函数不管是否是static, 在内存中只有一个副本, 

普通成员函数调用时, 需要传入this指针, static成员函数调用时, 没有this指针. ) 

请看示例程序四( <effective c++ (2nd)>(影印版)第59页) 

————————————————————————————————
class EnemyTarget { 

public: 

  EnemyTarget() { ++numTargets; } 
  EnemyTarget(const EnemyTarget&) { ++numTargets; } 
  ~EnemyTarget() { --numTargets; } 
  static size_t numberOfTargets() { return numTargets; } 
  bool destroy();   // returns success of attempt to destroy EnemyTarget object 

private: 

  static size_t numTargets;               // object counter 
}; 

// class statics must be defined outside the class; 
// initialization is to 0 by default 

size_t EnemyTarget::numTargets; 

————————————————————————————————————————

在这个例子中, 静态数据成员numTargets就是用来计数产生的对象个数的. 
另外, 在设计类的多线程操作时, 由于POSIX库下的线程函数pthread_create()要求是全局的, 普通成员函数无法直接做为线程函数, 可以考虑用Static成员函数做线程函数. 

=================================================================================

静态类成员包括静态数据成员和静态函数成员两部分。  
   
  一   静态数据成员：  
   
  1. 类体中的数据成员的声明前加上static关键字，该数据成员就成为了该类的静态数据成员。和其他数据成员一样，静态数据成员也遵守public/protected/private访问规则。同时，静态数据成员还具有以下特点：  
   
        1.静态数据成员的定义。  
            静态数据成员实际上是类域中的全局变量。所以，静态数据成员的定义(初始化)不应该被放在头文件中。  
        其定义方式与全局变量相同。举例如下：  
   ——————————————————————————————————————————————
        xxx.h文件  
        class   base{  
            private:  
            static   const   int   _i;//声明，标准c++支持有序类型在类体中初始化,但vc6不支持。  
        };    
   
        xxx.cpp文件  
        const   int   base::_i=10;//定义(初始化)时不受private和protected访问限制.  
  —————————————————————————————————————————————————— 
        注：不要试图在头文件中定义(初始化)静态数据成员。在大多数的情况下，这样做会引起重复定义这样的错误。即使加上#ifndef   #define   #endif或者#pragma   once也不行。  

2.静态数据成员被 类的所有对象所共享，包括该类派生类的对象。即派生类对象与基类对象共享基类的静态数据成员。举例如下： 

 ——————————————————————————————————————————————————————
        class   base{  
              public   :  
              static   int   _num;//声明  
        };  
        int   base::_num=0;//静态数据成员的真正定义  
   
        class   derived:public   base{  
        };  
   
        main()  
        {  
            base   a;  
            derived   b;  
            a._num++;  
            cout<<"base   class   static   data   number   _num   is"<<a._num<<endl;  
            b._num++;  
            cout<<"derived   class   static   data   number   _num   is"<<b._num<<endl;  
        }  
        //   结果为1,2;可见派生类与基类共用一个静态数据成员。  
   ————————————————————————————————————————————————————————

3.静态数据成员可以成为成员函数的可选参数，而普通数据成员则不可以。举例如下：  
      class   base{  
          public   :  
          static   int   _staticVar;  
          int   _var;  
          void   foo1(int   i=_staticVar);//正确,_staticVar为静态数据成员  
          void   foo2(int   i=_var);//错误,_var为普通数据成员  
      };          

—————————————————————————————————————————————————————————

 4.静态数据成员的类型可以是所属类的类型，而普通数据成员则不可以。普通数据成员的只能声明为   所属类类型的   指针或引用。举例如下：  
       
      class   base{  
          public   :  
          static   base   _object1;//正确，静态数据成员  
          base   _object2;//错误  
          base   *pObject;//正确，指针  
          base   &mObject;//正确，引用  
      };  
   ——————————————————————————————————————————————————————

5.这个特性，我不知道是属于标准c++中的特性，还是vc6自己的特性。  
        静态数据成员的值在const成员函数中可以被合法的改变。举例如下：  
   
      class   base{  
          public:  
          base(){_i=0;_val=0;}  
   
          mutable   int   _i;  
          static   int   _staticVal;    
          int   _val;  
          void   test()   const{//const   成员函数  
   
                _i++;//正确，mutable数据成员  
                _staticVal++;//正确，static数据成员  
                _val++;//错误  
   
          }  
      };  
      int   base::_staticVal=0;  

—————————————————————————————————————————————————————————

    二，静态成员函数  
      静态成员函数没有什么太多好讲的。  
   
      1.静态成员函数的地址可用普通函数指针储存，而普通成员函数地址需要用   类成员函数指针来储存。举例如下：  
          class   base{  
              static   int   func1();  
              int   func2();  
          };  
   
          int   (*pf1)()=&base::func1;//普通的函数指针  
          int   (base::*pf2)()=&base::func2;//成员函数指针  
   
   
      2.静态成员函数不可以调用类的非静态成员。因为静态成员函数不含this指针。  
   
      3.静态成员函数不可以同时声明为   virtual、const、volatile函数。举例如下：  

——————————————————————————————————————————————————

        class   base{  
              virtual   static   void   func1();//错误  
              static   void   func2()   const;//错误  
              static   void   func3()   volatile;//错误  
        };  

 ————————————————————————————————————————————————————
   
  最后要说的一点是，静态成员是可以独立访问的，也就是说，无须创建任何对象实例就可以访问。