static关键字用法学习

 

static关键字是C，C++中都存在的关键字，它主要有三种使用方式

       (1)局部静态变量  
  (2)外部静态变量/函数  
  (3)静态数据成员/成员函数  

下面就这三种使用方式及注意事项分别说明   

一、局部静态变量  
    在C/C++中，局部变量按照存储形式可分为三种auto，static，register。

与auto类型(普通)局部变量相比，static局部变量有三点不同   
       1.存储空间分配不同  
  auto类型分配在栈上，属于动态存储类别，占动态存储区空间，函数调用结束后自动释放，而static分配在静态存储区，在程序整个运行期间都不释放。两者之间的作用域相同，但生存期不同。   
       2.static局部变量在所处模块在初次运行时进行初始化工作，且只操作一次。
       3.对于局部静态变量，如果不赋初值，编译期会自动赋初值0或空字符，而auto类型的初值是不确定的。(对于C++中的class对象例外，class的对象实例如果不初始化，则会自动调用默认构造函数，不管是否是static类型)  
       特点：static局部变量具有“记忆性”与生存期的“全局性”。   
       所谓“记忆性”是指在两次函数调用时，在第二次调用进入时，能保持第一次调用退出时的值。  （和全局变量比起来，static可以控制变量的可见范围，详见注意事项二）
  示例程序一  
  #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;  
  }  
   
  应用:  
      利用“记忆性”，记录函数调用的次数 示例程序一：利用生存期的“全局性”，改善”return   a   pointer   /   reference   to   a   local   object”的问题。Local object的问题在于退出函数，生存期即结束。利用static的作用，延长变量的生存期。  
      注意事项:  
      1.“记忆性”，程序运行很重要的一点就是可重复性，而static变量的“记忆性”破坏了这种可重复性，造成不同时刻至运行的结果可能不同。  
      2.“生存期”全局性和唯一性。普通的local变量的存储空间分配在stack上，因此每次调用函数时，分配的空间都可能不一样，而static具有全局唯一性的特点，每次调用时，都指向同一块内存，这就造成一个很重要的问题——不可重入性!!!  
     这样在多线程程序设计或递归程序设计中，要特别注意这个问题。

比如:
 static int id = 0;
 sql = "select * from table where id=" + id;
 如果这样写的话，在单机测试的时候没有问题，但是在多人同时对数据进行测试的时候，就会有问题了。假如，A用户访问他的id是20，则id的值在内存中为20，而此时B用户访问，他的id是30,则id在内存中的值是30，A用户的id值则被更改了。如果此时你将这个方法用非静态成员来写，则不会出现这样的情况。因为非静态成员是你声明的时候，实例化的时候才会分配内存。所以A用户访问的时候，App会因为A实例化而给A用户的请求分配内存。而B用户访问的时候也一样会因为B用户的访问而分配内存。所以两个用户访问的是不同的内存块，所以不会出现数据覆盖和错乱的现象。  具体应用如下：
  ①   const   char   *   IpToStr(UINT32   IpAddr)  
  ②   {  
  ③     static   char   strBuff[16];   //   static局部变量，   用于返回地址有效  
  ④     const   unsigned   char   *pChIP   =   (const   unsigned   char   *)&IpAddr;  
  ⑤     sprintf(strBuff,"%u,%u,%u, %u", pChIP[0],pChIP[1],pChIP[2],pChIP[3]);  
  ⑥     return   strBuff;  
  ⑦   }  
      假设现在有两个线程A，B运行期间都需要调用IpToStr()函数，将32位的IP地址转换成点分10进制的字符串形式。现A先获得执行机会，执行IpToStr()，传入的参数是0x0B090A0A，顺序执行完应该返回的指针存储区内容是:”10,10,9,11”，现执行到⑥时，失去执行权，调度到B线程执行，B线程传入的参数是0xA8A8A8C0，执行至⑦，静态存储区的内容是192,168,168,168。当再调度到A执行时，从⑥继续执行，由于strBuff的全局唯一性，内容已经被B线程冲掉，此时返回的将是192,168,168,168字符串，不再是10,10,9,11字符串。  
   
  二、外部静态变量／函数  
      在C中static有了第二种含义：用来表示不能被其它文件访问的全局变量和函数。 
      当我们同时编译多个文件时，所有未加static前缀的全局变量和函数都具有全局可见性。为理解这句话，我举例来说明。我们要同时编译两个源文件，一个是a.c，另一个是main.c。

下面是a.c的内容

char a = 'A'; // global variable
void msg() 
{
    printf("Hello\n"); 
}

 

下面是main.c的内容

int main(void)
{    
    extern char a;    // extern variable must be declared before use
    printf("%c ", a);
    (void)msg();
    return 0;
}

你可能会问：为什么在a.c中定义的全局变量a和函数msg能在main.c中使用？前面说过，所有未加static前缀的全局变量和函数都具有全局可见性，其它的源文件也能访问。此例中，a是全局变量，msg是函数，并且都没有加static前缀，因此对于另外的源文件main.c是可见的。

但为了限制全局变量/函数的作用域，函数或变量前加static使得函数成为静态函数。但此处“static”的含义不是指存储方式，而是指对函数的作用域仅局限于本文件(所以又称内部函数)。注意此时，对于外部(全局)变量，不论是否有static限制，它的存储区域都是在静态存储区，生存期都是全局的。此时的static只是起作用域限制作用，限定作用域在本模块(文件)内部。  
    使用内部函数的好处是：不同的人编写不同的函数时，不用担心自己定义的函数，是否会与其它文件中的函数同名。
  三、静态数据成员／成员函数(C++特有)  
    C++重用了这个关键字，并赋予它与前面不同的第三种含义：表示属于一个类而不是属于此类的任何特定对象的变量和函数。这是与普通成员函数的最大区别，也是其应用所在，比如在对某一个类的对象进行计数时，计数生成多少个类的实例，就可以用到静态数据成员。在这里面，static既不是限定作用域的，也不是扩展生存期的作用，而是指示变量/函数在此类中的唯一性。这也是“属于一个类而不是属于此类的任何特定对象的变量和函数”的含义。因为它是对整个类来说是唯一的，因此不可能属于某一个实例对象的。(针对静态数据成员而言，成员函数不管是否是static，在内存中只有一个副本，普通成员函数调用时，需要传入this指针，static成员函数调用时，没有this指针。)  

  当然说到static,就避免不了要谈到static变量的初始化，

比如

class A

{

public:

    A(int val);

private:

    int mVal;

};

 

class B

{

private:

    static A m_A;

};

m_A怎么初始化？

规则：static成员一定要在类外初始化。

 这是因为被static声明的类静态数据成员，其实体远在main()函数开始之前就已经在全局数据段中诞生了(见《Inside   The   C++   Object   Model》page247)！其生命期和类对象是异步的，（而且静态语意说明即使没有类实体的存在,其静态数据成员的实体也是存的）这个时候对象的生命期还没有开始，如果你要到类中去初始化类静态数据成员,让静态数据成员的初始化依赖于类的实体,，那怎么满足前述静态语意呢?难道类永远不被实例化，我们就永远不能访问到被初始化的静态数据成员吗?

 另外类定义仅仅只是定义而已，没有分配内存空间的，所以不能初始化。 除了使用static   const   int   SIZE   =   10;   或   enum{SIZE   =   10};参看C++ Primer叙述如下：

【Ordinarily,   class   static   members,   like   ordinary   data   members,   cannot   be   initialized   in   the   class   body.   Instead,   static   data   members   are   normally   initialized   when   they   are   defined.

One   exception   to   this   rule   is   that   a   const   static   data   member   of   integral   type   can   be   initialized   within   the   class   body   as   long   as   the   initializer   is   a   constant   expression:

          class   Account   {

          public:

                  static   double   rate()   {   return   interestRate;   }

                  static   void   rate(double);     //   sets   a   new   rate

          private:

                  static   const   int   period   =   30;   //   interest   posted   every   30   days

                  double   daily_tbl[period];   //   ok:   period   is   constant   expression

          };

A   const   static   data   member   of   integral   type   initialized   with   a   constant   value   is   a   constant   expression.   As   such,   it   can   be   used   where   a   constant   expression   is  

required,   such   as   to   specify   the   dimension   for   the   array   member   daily_tbl.

 

  When   a   const   static   data   member   is   initialized   in   the   class   body,   the   data   member   must   still   be   defined   outside   the   class   definition.

When   an   initializer   is   provided   inside   the   class,   the   definition   of   the   member   must   not   specify   an   initial   value:

          //   definition   of   static   member   with   no   initializer;

          //   the   initial   value   is   specified   inside   the   class   definition

          const   int   Account::period;】

哦，还有一点需要补充的是static 成员应该在.cpp文件里定义，而不是放在.h文件中。一般的c++都是把一个.cpp文件编译成一个.obj文件,我们定义的static成员全局唯一，需要找一个obj文件放，你放在头文件里面，可以被include很多次，那到底放在那个obj里面呢？编译器不知道了吧，所以写在一个.cpp文件里面，这样才好办，编译器才知道放在.obj里面，link的时候也好办，明白了吧。
    另外,在设计类的多线程操作时,由于POSIX库下的线程函数pthread_create()要求是全局的,普通成员函数无法直接做为线程函数,可以考虑用static成员函数做线程函数。（