static、 const 、auto、register、const、volatile、extern的作用的作用

static的作用

   对于静态变量在内存中只有一个拷贝（节省内存）

在C语言中，static的字面意思很容易把我们导入歧途，其实它的作用有三条。

（1）先来介绍它的第一条也是最重要的一条：隐藏。

当我们同时编译多个文件时，所有未加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 Hello

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

如果加了static，就会对其它源文件隐藏。例如在a和msg的定义前加上static，main.c就看不到它们了。利用这一特性可以在不同的文件中定义同名函数和同名变量，而不必担心命名冲突。Static可以用作函数和变量的前缀，对于函数来讲，static的作用仅限于隐藏，而对于变量，static还有下面两个作用。

（2）static的第二个作用是 保持变量内容的持久 。 存储在静态数据区的变量会在程序刚开始运行时就完成初始化，也是唯一的一次初始化 。共有两种变量存储在静态存储区：全局变量和static变量，只不过和全局变量比起来，static可以控制变量的可见范围，说到底static还是用来隐藏的。虽然这种用法不常见，但我还是举一个例子。

#include <stdio.h>

int fun(void){
    static int count = 10;    // 只执行过一次
    return count--;
}

int count = 1;

int main(void)
{    
    printf("global\t\tlocal static\n");
    for(; count <= 10; ++count)

        printf("%d\t\t%d\n", count, fun());    
    
    return 0;
}
 

程序的运行结果是：

global          local static

1               10

2               9

3               8

4               7

5               6

6               5

7               4

8               3

9               2

10              1

 

（3）static的第三个作用是默认初始化为0。其实全局变量也具备这一属性，因为全局变量也存储在静态数据区。在静态数据区，内存中所有的字节默认值都是0x00，某些时候这一特点可以减少程序员的工作量。比如初始化一个稀疏矩阵，我们可以一个一个地把所有元素都置0，然后把不是0的几个元素赋值。如果定义成静态的，就省去了一开始置0的操作。再比如要把一个字符数组当字符串来用，但又觉得每次在字符数组末尾加’\0’太麻烦。如果把字符串定义成静态的，就省去了这个麻烦，因为那里本来就是’\0’。不妨做个小实验验证一下。

#include  < stdio.h >

int  a;

int  main( void )
{
     int  i;
     static   char  str[ 10 ];

    printf( " integer: %d;  string: (begin)%s(end) " , a, str);

     return   0 ;
}

程序的运行结果如下

integer: 0; string: (begin)(end)

最后对static的三条作用做一句话总结。首先static的最主要功能是隐藏，其次因为static变量存放在静态存储区，所以它具备持久性和默认值0。

const作用

对于C/C++语言来讲,const就是只读的意思,只在声明中使用;

static一般有2个作用,规定作用域和存储方式.

对于局部变量,static规定其为静态存储方式,每次调用的初始值为上一次调用的值,调用结束后存储空间不释放;

对于全局变量,如果以文件划分作用域的话,此变量只在当前文件可见;对于static函数也是在当前模块内函数可见.static const 应该就是上面两者的合集.

下面分别说明:

全局:const,只读的全局变量,其值不可修改.static,规定此全局变量只在当前模块(文件)中可见.static const,既是只读的,又是只在当前模块中可见的.

文件:文件指针可当作一个变量来看,与上面所说类似.

函数:const,返回只读变量的函数.static,规定此函数只在当前模块可见

.类:const,一般不修饰类,(在VC6.0中试了一下,修饰类没啥作用)static,C++中似乎没有静态类这个说法,一般还是拿类当特殊的变量来看.C#中有静态类的详细说明,且用法与普通类大不相同.

int main()
{
   int i=10;
   int j=1;
   const int *p1;//(1)
   int const *p2=&i; //(2)
   p2=&j;//(3)
   int *const p3=&i;//(4)
   *p3=20;//(5)
   *p2=30;//(6)
   p3=&j;//(7)
ret

（1） const  int*p1：表示不能通过指针p1修改它指向的内存单元的值，但是p1本身可修改。

（2） int  const*p2=&i：与p1相同，即不能修改p2指向的内存单元的值，但是可以修改p2使其指向其它的内存单元。这里p2指向了整型变量i

（3）p2=&j：修改p2，使其指向整型变量 j ，由（2）可知（3）没错。

（4） int * constp3=&i：p3本身是指向整型变量的常指针,即p3初始化后不能再指向其它的内存单元，但是可以修改p3指向的内存单元的值。这里p3指向了整型变量i。

（5）*p3=20：通过p3将变量i的值修改为2，由(4)可知（5）没错。

（6）*p2=30：通过p2修改它所指向的内存单元的值，由（2）可知（6）错误。

（7）p3=&j：修改p3,使其指向j,由(4)可知（7）错误。

const类型定义：指明变量或对象的值是不能被更新,引入目的是为了取代预编译指令 

**************常量必须被初始化*************************

const的作用
   （1）可以定义const常量         例如：
             const int Max=100;
             int Array[Max];        
   （2）便于进行类型检查            例如：
             void f(const int i) { .........}
        编译器就会知道i是一个常量，不允许修改；
   （3）可以保护被修饰的东西，防止意外的修改，增强程序的健壮性。
        还是上面的例子，如果在函数体内修改了i，编译器就会报错；
        例如： 
             void f(const int i) { i=10;//error! }
    (5) 为函数重载提供了一个参考。
         class A
         {
           ......
           void f(int i)       {......} file://一个函数
           void f(int i) const {......} file://上一个函数的重载
            ......
          };
     (6) 可以节省空间，避免不必要的内存分配。和宏调用的对比
         例如：
              #define PI 3.14159         file://常量宏
              const doulbe  Pi=3.14159;  file://此时并未将Pi放入ROM中
              ......
              double i=Pi;               file://此时为Pi分配内存，以后不再分配！
              double I=PI;               file://编译期间进行宏替换，分配内存
              double j=Pi;               file://没有内存分配
              double J=PI;               file://再进行宏替换，又一次分配内存！
         const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。
     （7） 提高了效率。
           编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。

使用const
   （1）修饰一般常量,常数组，常对象
　　 修饰符const可以用在类型说明符前，也可以用在类型说明符后。      例如：   
           int const x=2;　　或　　const int x=2;

　　     int const a[5]={1, 2, 3, 4, 5};    或  const int a[5]={1, 2, 3, 4, 5};

           class A;　     const A a;  或     A const a;
　　   
   （2）修饰指针
        const int *A;   或  int const *A; //const修饰指向的对象，A可变，A指向的对象不可变
        int *const A; 　            //const修饰指针A，     A不可变，A指向的对象可变 
        const int *const A;      //指针A和A指向的对象都不可变
   （3）修饰引用
 　　     const double & v;      该引用所引用的对象不能被更新
　（4）修饰函数的返回值：
        const修饰符也可以修饰函数的返回值，是返回值不可被改变，格式如下：
            const int Fun1(); 
            const MyClass Fun2();
   （5）修饰类的成员函数：
        const修饰符也可以修饰类的成员函数，格式如下：
            class ClassName 
     {
             public:
            　    　int Fun() const;
            　       .....
             }；
        这样，在调用函数Fun时就不能修改类里面的数据 
    （6）在另一连接文件中引用const常量
         extern const int i;     //正确的引用
         extern const int j=10;  //错误！常量不可以被再次赋值
   


*******************放在类内部的常量有什么限制？
  
        class A
        {
         private:
           const int c3 = 7;               // err
           static int c4 = 7;               // err
           static const float c5 = 7;  // err
          ......
  };
 初始化类内部的常量
        1 初始化列表：
         class A
         {
          public:
                A(int i=0):test(i) {}
          private:
                const int i;
          }；
         2 外部初始化，例如：
         class A
         {
          public:
                A() {}
          private:
                static const int i;  
          }；
          const int A::i=3;

(1)auto 
　　这个这个关键字用于声明变量的生存期为自动，即将不在任何类、结构、枚举、联合和函数中定义的变量视为全局变量，而在函数中定义的变量视为局部变量。所有的变量默认就是auto的。

(2)register 
　　这个关键字命令编译器尽可能的将变量存在CPU内部寄存器中而不是通过内存寻址访问以提高效率。用register声明的变量称着寄存器变量，在可能的情况下会直接存放在机器的寄存器中；但对32位编译器不起作用，当global optimizations（全局优化）开的时候，它会做出选择是否放在自己的寄存器中；不过其它与register关键字有关的其它符号都对32位编译器有效。

(3)static 
常见的两种用途: 
　　　　1>统计函数被调用的次数; 
　　　　2>减少局部数组建立和赋值的开销.变量的建立和赋值是需要一定的处理器开销的，特别是数组等含有较多元素的存储类型。在一些含有较多的变量并且被经常调用的函数中，可以将一些数组声明为static类型，以减少建立或者初始化这些变量的开销. 
详细说明: 
　　　　1>、变量会被放在程序的全局存储区中，这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。 
例如：

int max_so_far( int curr )//求至今（本次调用）为止最大值
{
     static int biggest; //该变量保持着每次调用时的最新值，它的有效期等于整个程序的有效期
     if( curr > biggest )
        biggest = curr;
     return biggest;
}

　　　　2>、变量用static告知编译器，自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别。 
　　　　3>当static用来修饰全局变量时，它就改变了全局变量的作用域，使其不能被别的程序extern，限制在了当前文件里，但是没有改变其存放位置，还是在全局静态储存区。

使用注意: 
　　　　1>若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度； 
　　　　2>若全局变量仅由单个函数访问，则可以将这个变量改为该函数的静态局部变量，以降低模块间的耦合度； 
　　　　3>设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑重入问题(只要输入数据相同就应产生相同的输出)。

(4)const 
　　被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。它可以修饰函数的参数、返回值，甚至函数的定义体。 
　　作用: 
　　　　1>修饰输入参数 
　　　　　　a.对于非内部数据类型的输入参数，应该将“值传递”的方式改为“const引用传递”，目的是提高效率。例如将void Func(A a) 改为void Func(const A &a)。 
　　　　　　b.对于内部数据类型的输入参数，不要将“值传递”的方式改为“const引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void Func(int x) 不应该改为void Func(const int &x)。 
　　　　2>用const修饰函数的返回值 
　　　　　　a.如果给以“指针传递”方式的函数返回值加const修饰，那么函数返回值（即指针）的内容不能被修改，该返回值只能被赋给加const修饰的同类型指针。 
　　　　　　如对于： const char * GetString(void); 
　　　　　　如下语句将出现编译错误： 
　　　　　　 char str = GetString();//cannot convert from ‘const char ’ to ‘char *’； 
　　　　　　正确的用法是： 
　　　　　　　const char *str = GetString(); 
　　　　　　b.如果函数返回值采用“值传递方式”，由于函数会把返回值复制到外部临时的存储单元中，加const修饰没有任何价值。 如不要把函数int GetInt(void) 写成const int GetInt(void)。 
　　　　3>const成员函数的声明中，const关键字只能放在函数声明的尾部,表示该类成员不修改对象. 
　　　说明： 
　　　　const type m; //修饰m为不可改变 
　　　示例： 
　　　　typedef char * pStr; //新的类型pStr; 
　　　　char string[4] = “abc”; 
　　　　const char *p1 = string； 
　　　　p1++; //正确，上边修饰的是*p1,p1可变 
　　　　const pStr p2 = string; 
　　　　p2++; //错误，上边修饰的是p2，p2不可变,*p2可变 
　　　同理，const修饰指针时用此原则判断就不会混淆了。 
　　　　const int *value; //*value不可变，value可变 
　　　　int* const value; //value不可变，*value可变 
　　　　const (int ) value; //(int )是一种type,value不可变,*value可变 
　　　　　　　　　　　　　　//逻辑上这样理解，编译不能通过，需要tydef int* NewType; 
　　　　const int* const value;//*value,value都不可变

(5)volatile 
　　表明某个变量的值可能在外部被改变，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。它可以适用于基础类型如：int,char,long……也适用于C的结构和C++的类。当对结构或者类对象使用volatile修饰的时候，结构或者类的所有成员都会被视为volatile. 
　　该关键字在多线程环境下经常使用，因为在编写多线程的程序时，同一个变量可能被多个线程修改，而程序通过该变量同步各个线程。 
　　简单示例： 
　　　

DWORD __stdcall threadFunc(LPVOID signal) 
　　　{ 
　　　　　int* intSignal=reinterpret_cast(signal); 
　　　　　*intSignal=2; 
　　　　　while(*intSignal!=1) 
　　　　　sleep(1000); 
　　　　　return 0; 
　　　} 
　　该线程启动时将intSignal 置为2，然后循环等待直到intSignal 为1 时退出。显然intSignal的值必须在外部被改变，否则该线程不会退出。但是实际运行的时候该线程却不会退出，即使在外部将它的值改为1，看一下对应的伪汇编代码就明白了： 
　　　　　mov ax,signal 
　　　　　label: 
　　　　　if(ax!=1) 
　　　　　goto label 
　　对于C编译器来说，它并不知道这个值会被其他线程修改。自然就把它cache在寄存器里面。C 编译器是没有线程概念的,这时候就需要用到volatile。volatile 的本意是指：这个值可能会在当前线程外部被改变。也就是说，我们要在threadFunc中的intSignal前面加上volatile关键字，这时候，编译器知道该变量的值会在外部改变，因此每次访问该变量时会重新读取，所作的循环变为如下面伪码所示： 
label: 
　　　　　mov ax,signal 
　　　　　if(ax!=1) 
　　　　　goto label 
　　注意：一个参数既可以是const同时是volatile，是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。

(6)extern 
　　extern 意为“外来的”···它的作用在于告诉编译器：有这个变量，它可能不存在当前的文件中，但它肯定要存在于工程中的某一个源文件中或者一个Dll的输出中。声明变量或函数为外部链接，即该变量或函数名在其它文件中可见。被其修饰的变量（外部变量）是静态分配空间的，即程序开始时分配，结束时释放。用其声明的变量或函数应该在别的文件或同一文件的其它地方定义（实现）。在文件内声明一个变量或函数默认为可被外部使用。

转自http://www.cnblogs.com/candyming/archive/2011/11/25/2262826.html