C++中变量的存储类别和属性

我不是女神ヾ 2022-06-10 00:09 204阅读 0赞

**C++变量的存储类别（动态存储、静态存储、自动变量、寄存器变量、外部变量）**  
动态存储方式与静态存储方式

我们已经了解了变量的作用域。作用域是从空间的角度来分析的，分为全局变量和局部变量。

变量还有另一种属性——存储期(storage duration，也称生命期)。存储期是指变量在内存中的存在期间。这是从变量值存在的时间角度来分析的。存储期可以分为静态存储期(static storage duration)和动态存储期(dynamic storage duration)。这是由变量的静态存储方式和动态存储方式决定的。

所谓静态存储方式是指在程序运行期间，系统对变量分配固定的存储空间。而动态存储方式则是在程序运行期间，系统对变量动态地分配存储空间。

先看一下内存中的供用户使用的存储空间的情况。这个存储空间可以分为三部分，即：

1.  程序区
2.  静态存储区
3.  动态存储区  
    ![2015911152729275.png_2015811152743][]

数据分别存放在静态存储区和动态存储区中。全局变量全部存放在静态存储区中，在程序开始执行时给全局变量分配存储单元，程序执行完毕就释放这些空间。在程序执行过程中它们占据固定的存储单元，而不是动态地进行分配和释放。

在动态存储区中存放以下数据：  
函数形式参数。在调用函数时给形参分配存储空间。  
函数中的自动变量(未加static声明的局部变量，详见后面的介绍)。  
函数调用时的现场保护和返回地址等。

动态变量和静态变量定义和区别如下：  
1、定义上，静态变量比动态变量多一个关键字static，比如：  
动态变量：int i;  
静态变量：static int i;  
2、动态变量在子程序中，每次调用时都会从零开始，不会保留原有数据，静态变量调用时原有值不会发生改变

可以简单理解为：静态在整个过程中无特殊操作不可变，动态在整个过程中每次都可变。

对以上这些数据，在函数调用开始时分配动态存储空间，函数结束时释放这些空间。在程序执行过程中，这种分配和释放是动态的，如果在一个程序中两次调用同一函数，则要进行两次分配和释放，而两次分配给此函数中局部变量的存储空间地址可能是不相同的。

如果在一个程序中包含若干个函数，每个函数中的局部变量的存储期并不等于整个程序的执行周期，它只是整个程序执行周期的一部分。根据函数调用的情况，系统对局部变量动态地分配和释放存储空间。

在C++中变量除了有数据类型的属性之外，还有存储类别(storage class) 的属性。存储类别指的是数据在内存中存储的方法。存储方法分为静态存储和动态存储两大类。具体包含4种：自动的(auto)、静态的(static)、寄存器的(register)和外部的(extern)。根据变量的存储类别，可以知道变量的作用域和存储期。  
自动变量

函数中的局部变量，如果不用关键字static加以声明，编译系统对它们是动态地分配存储空间的。函数的形参和在函数中定义的变量(包括在复合语句中定义的变量)都属此类。在调用该函数时，系统给形参和函数中定义的变量分配存储空间，数据存储在动态存储区中。在函数调用结束时就自动释放这些空间。如果是在复合语句中定义的变量，则在变量定义时分配存储空间，在复合语句结束时自动释放空间。因此这类局部变量称为自动变量(auto variable)。自动变量用关键字auto作存储类别的声明。例如：

[?][Link 1]

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>int</code> 
      <code> f(</code> 
      <code>int</code> 
      <code>a) </code> 
      <code>//定义f函数，a为形参</code> 
     </div> 
     <div> 
      <code>{ </code> 
     </div> 
     <div> 
      <code></code> 
      <code>auto </code> 
      <code>int</code> 
      <code>b, c=3; </code> 
      <code>//定义b和c为整型的自动变量</code> 
     </div> 
     <div> 
      <code>}</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

存储类别auto和数据类型int的顺序任意。关键字auto可以省略，如果不写auto，则系统把它默认为自动存储类别，它属于动态存储方式。程序中大多数变量属于自动变量。本教程前面各章所介绍的例子中，在函数中定义的变量都没有声明为auto，其实都默认指定为自动变量。在函数体中以下两种写法作用相同：

[?][Link 1]

用static声明静态局部变量

有时希望函数中的局部变量的值在函数调用结束后不消失而保留原值，即其占用的存储单元不释放，在下一次该函数调用时，该变量保留上一次函数调用结束时的值。这时就应该指定该局部变量为静态局部变量(static local variable)。

【例】静态局部变量的值。

[?][Link 1]

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> 
    <div>
      9 
    </div> 
    <div>
      10 
    </div> 
    <div>
      11 
    </div> 
    <div>
      12 
    </div> 
    <div>
      13 
    </div> 
    <div>
      14 
    </div> 
    <div>
      15 
    </div> 
    <div>
      16 
    </div> 
    <div>
      17 
    </div> 
    <div>
      18 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>#include &lt;iostream&gt;</code> 
     </div> 
     <div> 
      <code>using</code> 
      <code>namespace</code> 
      <code>std;</code> 
     </div> 
     <div> 
      <code>int</code> 
      <code> f(</code> 
      <code>int</code> 
      <code>a) </code> 
      <code>//定义f函数,a为形参</code> 
     </div> 
     <div> 
      <code>{ </code> 
     </div> 
     <div> 
      <code></code> 
      <code>auto </code> 
      <code>int</code> 
      <code>b=0; </code> 
      <code>//定义b为自动变量</code> 
     </div> 
     <div> 
      <code></code> 
      <code>static</code> 
      <code>int</code> 
      <code>c=3; </code> 
      <code>//定义c为静态局部变量</code> 
     </div> 
     <div> 
      <code></code> 
      <code>b=b+1;</code> 
     </div> 
     <div> 
      <code></code> 
      <code>c=c+1;</code> 
     </div> 
     <div> 
      <code></code> 
      <code>return</code> 
      <code>a+b+c;</code> 
     </div> 
     <div> 
      <code>}</code> 
     </div> 
     <div> 
      <code>int</code> 
      <code> main( )</code> 
     </div> 
     <div> 
      <code>{ </code> 
     </div> 
     <div> 
      <code></code> 
      <code>int</code> 
      <code>a=2,i;</code> 
     </div> 
     <div> 
      <code></code> 
      <code>for</code> 
      <code>(i=0;i&lt;3;i++)</code> 
     </div> 
     <div> 
      <code></code> 
      <code>cout&lt;&lt;f(a)&lt;&lt;</code> 
      <code>" "</code> 
      <code>;</code> 
     </div> 
     <div> 
      <code></code> 
      <code>cout&lt;&lt;endl;</code> 
     </div> 
     <div> 
      <code></code> 
      <code>return</code> 
      <code>0;</code> 
     </div> 
     <div> 
      <code>}</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

运行结果为：

[?][Link 1]

先后3次调用f函数时，b和c的值如表所示。

![2015911152848393.jpg_2015811152858][]  
对静态局部变量的说明：  
静态局部变量在静态存储区内分配存储单元。在程序整个运行期间都不释放。而自动变量(即动态局部变量)属于动态存储类别，存储在动态存储区空间(而不是静态存储区空间)，函数调用结束后即释放。  
为静态局部变量赋初值是在编译时进行值的，即只赋初值一次，在程序运行时它已有初值。以后每次调用函数时不再重新赋初值而只是保留上次函数调用结束时的值。而为自动变量赋初值，不是在编译时进行的，而是在函数调用时进行，每调用一次函数重新给一次初值，相当于执行一次赋值语句。  
如果在定义局部变量时不赋初值的话，对静态局部变量来说，编译时自动赋初值0(对数值型变量)或空字符(对字符型变量)。而对自动变量来说，如果不赋初值，则它的值是一个不确定的值。这是由于每次函数调用结束后存储单元已释放，下次调用时又重新另分配存储单元，而所分配的单元中的值是不确定的。  
虽然静态局部变量在函数调用结束后仍然存在，但其他函数是不能引用它的，也就是说，在其他函数中它是“不可见”的。

在什么情况下需要用局部静态变量呢？

1) 需要保留函数上一次调用结束时的值。例如可以用下例中的方法求n!。

【例】输出1~5的阶乘值(即1!，2!，3!，4!，5!)。

[?][Link 1]

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> 
    <div>
      9 
    </div> 
    <div>
      10 
    </div> 
    <div>
      11 
    </div> 
    <div>
      12 
    </div> 
    <div>
      13 
    </div> 
    <div>
      14 
    </div> 
    <div>
      15 
    </div> 
    <div>
      16 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>#include &lt;iostream&gt;</code> 
     </div> 
     <div> 
      <code>using</code> 
      <code>namespace</code> 
      <code>std;</code> 
     </div> 
     <div> 
      <code>int</code> 
      <code> fac(</code> 
      <code>int</code> 
      <code>); </code> 
      <code>//函数声明</code> 
     </div> 
     <div> 
      <code>int</code> 
      <code> main( )</code> 
     </div> 
     <div> 
      <code>{ </code> 
     </div> 
     <div> 
      <code></code> 
      <code>int</code> 
      <code>i;</code> 
     </div> 
     <div> 
      <code></code> 
      <code>for</code> 
      <code>(i=1;i&lt;=5;i++)</code> 
     </div> 
     <div> 
      <code></code> 
      <code>cout&lt;&lt;i&lt;&lt;</code> 
      <code>"!="</code> 
      <code>&lt;&lt;fac(i)&lt;&lt;endl;</code> 
     </div> 
     <div> 
      <code></code> 
      <code>return</code> 
      <code>0;</code> 
     </div> 
     <div> 
      <code>}</code> 
     </div> 
     <div> 
      <code>int</code> 
      <code> fac(</code> 
      <code>int</code> 
      <code>n)</code> 
     </div> 
     <div> 
      <code>{ </code> 
     </div> 
     <div> 
      <code></code> 
      <code>static</code> 
      <code>int</code> 
      <code>f=1; </code> 
      <code>//<span style="color:#ff0000">f为静态局部变量，函数结束时f的值不释放</span></code> 
     </div> 
     <div> 
      <code></code> 
      <code>f=f*n; </code> 
      <code>//在f原值基础上乘以n</code> 
     </div> 
     <div> 
      <code></code> 
      <code>return</code> 
      <code>f;</code> 
     </div> 
     <div> 
      <code>}</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

运行结果为

[?][Link 1]

每次调用fac(i)，就输出一个i，同时保留这个i!的值，以便下次再乘(i+1)。

2) 如果初始化后，变量只被引用而不改变其值，则这时用静态局部变量比较方便，以免每次调用时重新赋值。 但是应该看到，用静态存储要多占内存，而且降低了程序的可读性，当调用次数多时往往弄不清静态局部变量的当前值是什么。因此，如不必要，不要多用静态局部变量。  
用register声明寄存器变量

一般情况下，变量的值是存放在内存中的。当程序中用到哪一个变量的值时，由控制器发出指令将内存中该变量的值送到CPU中的运算器。经过运算器进行运算，如果需要存数，再从运算器将数据送到内存存放。如图所示。

![2015911152923929.png_2015811152938][]  
为提高执行效率，C++允许将局部变量的值放在CPU中的寄存器中，需要用时直接从寄存器取出参加运算，不必再到内存中去存取。这种变量叫做寄存器变量，用关键字register作声明。例如，可以将例4.14中的fac函数改写如下：

[?][Link 1]

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>int</code> 
      <code> fac(</code> 
      <code>int</code> 
      <code>n)</code> 
     </div> 
     <div> 
      <code>{ </code> 
     </div> 
     <div> 
      <code></code> 
      <code>register</code> 
      <code>int</code> 
      <code>i,f=1; </code> 
      <code>//定义i和f是寄存器变量</code> 
     </div> 
     <div> 
      <code></code> 
      <code>for</code> 
      <code>(i=1;i&lt;=n;i++) f=f*i;</code> 
     </div> 
     <div> 
      <code></code> 
      <code>return</code> 
      <code>f;</code> 
     </div> 
     <div> 
      <code>}</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

定义f和i是存放在寄存器的局部变量，如果n的值大，则能节约许多执行时间。

在程序中定义寄存器变量对编译系统只是建议性(而不是强制性)的。当今的优化编译系统能够识别使用频繁的变量，自动地将这些变量放在寄存器中。  
用extern声明外部变量

全局变量(外部变量)是在函数的外部定义的，它的作用域为从变量的定义处开始，到本程序文件的末尾。在此作用域内，全局变量可以为本文件中各个函数所引用。编译时将全局变量分配在静态存储区。

有时需要用extern来声明全局变量，以扩展全局变量的作用域。

1) 在一个文件内声明全局变量  
如果外部变量不在文件的开头定义，其有效的作用范围只限于定义处到文件终了。如果在定义点之前的函数想引用该全局变量，则应该在引用之前用关键字extern对该变量作外部变量声明，表示该变量是一个将在下面定义的全局变量。有了此声明，就可以从声明处起，合法地引用该全局变量，这种声明称为提前引用声明。

【例】用extern对外部变量作提前引用声明，以扩展程序文件中的作用域。

[?][Link 1]

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> 
    <div>
      9 
    </div> 
    <div>
      10 
    </div> 
    <div>
      11 
    </div> 
    <div>
      12 
    </div> 
    <div>
      13 
    </div> 
    <div>
      14 
    </div> 
    <div>
      15 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>#include &lt;iostream&gt;</code> 
     </div> 
     <div> 
      <code>using</code> 
      <code>namespace</code> 
      <code>std;</code> 
     </div> 
     <div> 
      <code>int</code> 
      <code> max(</code> 
      <code>int</code> 
      <code>,</code> 
      <code>int</code> 
      <code>); </code> 
      <code>//函数声明</code> 
     </div> 
     <div> 
      <code>void</code> 
      <code> main( )</code> 
     </div> 
     <div> 
      <code>{ </code> 
     </div> 
     <div> 
      <code></code> 
      <code>extern</code> 
      <code>int</code> 
      <code>a,b;</code> 
      <code>//对全局变量a,b作提前引用声明</code> 
     </div> 
     <div> 
      <code></code> 
      <code>cout&lt;&lt;max(a,b)&lt;&lt;endl;</code> 
     </div> 
     <div> 
      <code>}</code> 
     </div> 
     <div> 
      <code>int</code> 
      <code> a=15,b=-7;</code> 
      <code>//定义全局变量a,b</code> 
     </div> 
     <div> 
      <code>int</code> 
      <code> max(</code> 
      <code>int</code> 
      <code>x,</code> 
      <code>int</code> 
      <code>y)</code> 
     </div> 
     <div> 
      <code>{ </code> 
     </div> 
     <div> 
      <code></code> 
      <code>int</code> 
      <code>z;</code> 
     </div> 
     <div> 
      <code></code> 
      <code>z=x&gt;y?x:y;</code> 
     </div> 
     <div> 
      <code></code> 
      <code>return</code> 
      <code>z;</code> 
     </div> 
     <div> 
      <code>}</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

运行结果如下：

[?][Link 1]

在main后面定义了全局变量a，b，但由于全局变量定义的位置在函数main之后，因此如果没有程序的第5行，在main函数中是不能引用全局变量a和b的。现在我们在main函数第2行用extern对a和b作了提前引用声明，表示a和b是将在后面定义的变量。这样在main函数中就可以合法地使用全局变量a和b了。如果不作extern声明，编译时会出错，系统认为a和b未经定义。一般都把全局变量的定义放在引用它的所有函数之前，这样可以避免在函数中多加一个extern声明。

2) 在多文件的程序中声明外部变量  
如果一个程序包含两个文件，在两个文件中都要用到同一个外部变量num，不能分别在两个文件中各自定义一个外部变量num。正确的做法是：在任一个文件中定义外部变量num，而在另一文件中用extern对num作外部变量声明。即

[?][Link 1]

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>extern</code> 
      <code>int</code> 
      <code>num;</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

编译系统由此知道num是一个已在别处定义的外部变量，它先在本文件中找有无外部变量num，如果有，则将其作用域扩展到本行开始(如上节所述)，如果本文件中无此外部变量，则在程序连接时从其他文件中找有无外部变量num，如果有，则把在另一文件中定义的外部变量num的作用域扩展到本文件，在本文件中可以合法地引用该外部变量num。

分析下例：  
filel.cpp

[?][Link 1]

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> 
    <div>
      9 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>extern</code> 
      <code>int</code> 
      <code>a,b;</code> 
     </div> 
     <div> 
      <code>int</code> 
      <code> main()</code> 
     </div> 
     <div> 
      <code>{ </code> 
     </div> 
     <div> 
      <code></code> 
      <code>cout&lt;&lt;a&lt;&lt;</code> 
      <code>","</code> 
      <code>&lt;&lt;b&lt;&lt;end!;</code> 
     </div> 
     <div> 
      <code></code> 
      <code>return</code> 
      <code>0;</code> 
     </div> 
     <div> 
      <code>}</code> 
     </div> 
     <div></div> 
     <div> 
      <code>file2.cpp</code> 
     </div> 
     <div> 
      <code>int</code> 
      <code> as3,b=4;</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

┆

在源程序文件ffle2.cpp中定义了整型变量a和b，并賦了初值。在filel.cpp中用extern声明外部变量a和b，未賦值。在编译连接成一个程序后，file2.cpp中的a和b的作用域扩展到file2.cpp文件中，因此main函数中的cout语句输出a和b的值为3和4。

用extern扩展全局变量的作用域，虽然能为程序设计带来方便，但应十分慎重，因为在执行一个文件中的函数时，可能会改变了该全局变量的值，从而会影响到另一文件中的函数执行结果。  
用static声明静态外部变量

有时在程序设计中希望某些外部变量只限于被本文件引用，而不能被其他文件引用。这时可以在定义外部变量时加一个static声明。例如：  
file1.cpp

[?][Link 1]

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>static</code> 
      <code>int</code> 
      <code>a=3;</code> 
     </div> 
     <div> 
      <code>int</code> 
      <code> main ( )</code> 
     </div> 
     <div> 
      <code>{ </code> 
     </div> 
     <div> 
      <code></code> 
      <code>┆</code> 
     </div> 
     <div> 
      <code>}</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

file2.cpp

[?][Link 1]

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>extern</code> 
      <code>int</code> 
      <code>a;</code> 
     </div> 
     <div> 
      <code>int</code> 
      <code> fun (</code> 
      <code>int</code> 
      <code>n)</code> 
     </div> 
     <div> 
      <code>{ </code> 
     </div> 
     <div> 
      <code></code> 
      <code>┆</code> 
     </div> 
     <div> 
      <code></code> 
      <code>a=a*n;</code> 
     </div> 
     <div> 
      <code></code> 
      <code>┆</code> 
     </div> 
     <div> 
      <code>}</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

在filel.cpp中定义了一个全局变量a，但它用static声明，因此只能用于本文件，虽然 在cpp文件中用了“extern int a;”，但file2.cpp文件中仍然无法使用filel.cpp中的全局变量a。

这种加上static声明、只能用于本文件的外部变量(全局变量)称为静态外部变量。这就为程序的模块化、通用性提供了方便。如果已知道其他文件不需要引用本文件的全局变量，可以对本文件中的全局变量都加上static，成为静态外部变量，以免被其他文件误用。

需要指出，不要误认为用static声明的外部变量才采用静态存储方式(存放在静态存储区中)，而不加static的是动态存储(存放在动态存储区)。实际上，两种形式的外部变量都用静态存储方式，只是作用范围不同而已，都是在编译时分配内存的。

**C++变量属性小结**  
一个变量除了数据类型以外，还有3种属性：  
存储类别 C++允许使用auto，static，register和extern 4种存储类别。  
作用域 指程序中可以引用该变量的区域。（全局和局部）  
存储期 指变量在内存的存储期限。（动态和静态）

以上3种属性是有联系的，程序设计者只能声明变量的存储类别，通过存储类别可以确定变量的作用域和存储期。

要注意存储类别的用法。auto， static和register 3种存储类别只能用于变量的定义语句中，如：

[?][Link 1]

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>auto </code> 
      <code>char</code> 
      <code>c; </code> 
      <code>//字符型自动变量，在函数内定义</code> 
     </div> 
     <div> 
      <code>static</code> 
      <code>int</code> 
      <code>a; </code> 
      <code>//静态局部整型变量或静态外部整型变量</code> 
     </div> 
     <div> 
      <code>register</code> 
      <code>int</code> 
      <code>d; </code> 
      <code>//整型寄存器变量，在函数内定义</code> 
     </div> 
     <div> 
      <code>extern</code> 
      <code>int</code> 
      <code>b; </code> 
      <code>//声明一个已定义的外部整型变量</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

说明： extern只能用来声明已定义的外部变量，而不能用于变量的定义。只要看到extern，就可以判定这是变量声明，而不是定义变量的语句。

下面从不同角度分析它们之间的联系。

1) 从作用域角度分，有局部变量和全局变量。它们采用的存储类别如下：  
局部变量  
   自动变量，即动态局部变量(离开函数，值就消失)  
        静态局部变量(离开函数，值仍保留)  
   寄存器变量(离开函数，值就消失)  
        形式参数(可以定义为自动变量或寄存器变量)  
全局变量  
   静态外部变量(只限本文件引用)  
  外部变量(即非静态的外部变量，允许其他文件引用)  
2) 从变量存储期(存在的时间)来区分，有动态存储和静态存储两种类型。静态存储是程序整个运行时间都存在，而动态存储则是在调用函数时临时分配单元。  
动态存储  
       自动变量(本函数内有效)  
       寄存器变量(本函数内有效)  
       形式参数  
静态存储  
        静态局部变量(函数内有效)  
        静态外部变量(本文件内有效)  
        外部变量(其他文件可引用)

3) 从变量值存放的位置。可分为：  
       内存中静态存储区  
       静态局部变量  
       静态外部变量(函数外部静态变量)  
       外部变量(可为其他文件引用)  
       内存中动态存储区： 自动变量和形式参数  
       CPU 中的寄存器： 寄存器变量

4) 关于作用域和存储期的概念。

从前面叙述可以知道，对一个变量的性质可以从两个方面分析，一是从变量的作用域，一是从变量值存在时间的长短，即存储期。前者是从空间的角度，后者是从时间的角度。二者有联系但不是同一回事。下图是作用域的示意图，下图是存储期的示意图。

![2015911152952245.png_201581115301][]

![2015911153011313.png_2015811153021][]  
如果一个变量在某个文件或函数范围内是有效的，则称该文件或函数为该变量的作用域，在此作用域内可以引用该变量，所以又称变量在此作用域内“可见”，这种性质又称为变量的可见性，例如图中变量a?b在函数f1中可见。

如果一个变量值在某一时刻是存在的，则认为这一时刻属于该变量的存储期，或称该变量在此时刻“存在”。下表表示各种类型变量的作用域和存在性的情况。

![2015911153029443.jpg_2015811153041][]  
其中“√”表示是，“X”表示否。可以看到自动变量和寄存器变量在函数内的可见性和存在性是一致的。在函数外的可见性和存在性也是一致的。静态局部变量在函数外的可见性和存在性不一致。静态外部变量和外部变量的可见性和存在性是一致的。

如果一个变量在某个文件或函数范围内是有效的，则称该文件或函数为该变量的作用域，在此作用域内可以引用该变量，所以又称变量在此作用域内“可见”，这种性质又称为变量的可见性，例如图中变量a?b在函数f1中可见。

如果一个变量值在某一时刻是存在的，则认为这一时刻属于该变量的存储期，或称该变量在此时刻“存在”。书中表表示各种类型变量的作用域和存在性的情况。  
可以看到自动变量和寄存器变量在函数内的可见性和存在性是一致的。在函数外的可见性和存在性也是一致的。静态局部变量在函数外的可见性和存在性不一致。静态外部变量和外部变量的可见性和存在性是一致的。

5) static声明使变量采用静态存储方式，但它对局部变量和全局变量所起的作用不同。

对局部变量来说，static使变量由动态存储方式改变为静态存储方式。而对全局变量来说，它使变量局部化(局部于本文件)，但仍为静态存储方式。从作用域角度看，凡有static声明的，其作用域都是局限的，或者局限于本函数内(静态局部变量)，或者局限于本文件内(静态外部变量)。

[2015911152729275.png_2015811152743]: http://files.jb51.net/file_images/article/201509/2015911152729275.png?2015811152743
[Link 1]: http://www.jb51.net/article/72127.htm#
[2015911152848393.jpg_2015811152858]: http://files.jb51.net/file_images/article/201509/2015911152848393.jpg?2015811152858
[2015911152923929.png_2015811152938]: http://files.jb51.net/file_images/article/201509/2015911152923929.png?2015811152938
[2015911152952245.png_201581115301]: http://files.jb51.net/file_images/article/201509/2015911152952245.png?201581115301
[2015911153011313.png_2015811153021]: http://files.jb51.net/file_images/article/201509/2015911153011313.png?2015811153021
[2015911153029443.jpg_2015811153041]: http://files.jb51.net/file_images/article/201509/2015911153029443.jpg?2015811153041