c语言中static用法总结

参考：

http://www.jcwcn.com/article-31891-1.html

一、c程序存储空间布局

C程序一直由下列部分组成：

1. 正文段——CPU执行的机器指令部分；一个程序只有一个副本；只读，防止程序由于意外事故而修改自身指令；
2. 初始化数据段（数据段data）——在程序中所有赋了初值的全局变量，存放在这里。
3. 非初始化数据段（bss段）——在程序中没有初始化的全局变量；内核将此段初始化为0。
4. 栈——增长方向：自顶向下增长；自动变量以及每次函数调用时所需要保存的信息（返回地址；环境信息）。
5. 堆——动态存储分配。

|-----------|
|           |
|-----------|
|    栈    | 
|-----------|
|    |      |
|   \|/    |
|           |
|           |
|   /|\    |
|    |      |
|-----------|
|    堆    |
|-----------|
| 未初始化bss|
|-----------|
| 初始化data |
|-----------|
| 正文段 |

|-----------|

二、 面向过程程序设计中的static

1. 全局静态变量

在全局变量之前加上关键字static，全局变量就被定义成为一个全局静态变量。

1. 内存中的位置：静态存储区（静态存储区在整个程序运行期间都存在）
2. 初始化：未经初始化的全局静态变量会被程序自动初始化为0（自动对象的值是任意的，除非他被显示初始化）
3. 作用域：全局静态变量在声明他的文件之外是不可见的。准确地讲从定义之处开始到文件结尾。

看下面关于作用域的程序：

//teststatic1.cvoid display();extern int n;int main(){    n = 20;    printf("%d\n",n);    display();    return 0;}

//teststatic2.cstatic int n; //定义全局静态变量，自动初始化为0，仅在本文件中可见void display(){    n++;    printf("%d\n",n);} 

文件分别编译通过，但link的时候teststatic1.c中的变量n找不到定义，产生错误。

 
定义全局静态变量的好处：
<1>不会被其他文件所访问，修改

<2>其他文件中可以使用相同名字的变量，不会发生冲突。

2. 局部静态变量

在局部变量之前加上关键字static，局部变量就被定义成为一个局部静态变量。

1. 内存中的位置：静态存储区（静态存储区在整个程序运行期间都存在）
2. 初始化：未经初始化的全局静态变量会被程序自动初始化为0（自动对象的值是任意的，除非他被显示初始化）
3. 作用域：作用域仍为局部作用域，当定义它的函数或者语句块结束的时候，作用域随之结束。

当static用来修饰局部变量的时候，它就改变了局部变量的存储位置，从原来的栈中存放改为静态存储区。但是局部静态变量在离开作用域之后，并没有被销毁，而是仍然驻留在内存当中。退出该函数后， 尽管该变量还继续存在，但不能使用它。

static对栈变量的修饰，可以认为栈变量的生命周期延长到程序执行结束时。一般来说，栈变量的生命周期由OS管理，在退栈的过程中，栈变量的生命也就结束了。但加入static修饰之后，变量已经不在存储在栈中，而是和全局变量一起存储。同时，离开定义它的函数后不能使用，但如再次调用定义它的函数时，它又可继续使用， 而且保存了前次被调用后留下的值。

      当static用来修饰全局变量的时候，它就改变了全局变量的作用域（在声明他的文件之外是不可见的），但是没有改变它的存放位置，还是在静态存储区中。

      static修饰局部变量的时候，改变了局部变量的存储位置，但没改变作用域。

3. 静态函数

  在函数的返回类型前加上关键字static，函数就被定义成为静态函数。
  函数的定义和声明默认情况下是extern的，但静态函数只是在声明他的文件当中可见，不能被其他文件所用。
  例如：

//teststatic1.cvoid display();static void staticdis();int main(){    display();    staticdis();    return 0;}

//teststatic2.cvoid display(){    staticdis();    printf("display() has been called \n");}static void staticdis(){    printf("staticDis() has been called\n");}

 
文件分别编译通过，但是连接的时候找不到函数staticdis()的定义，产生错误。
 

定义静态函数的好处：

<1> 其他文件中可以定义相同名字的函数，不会发生冲突。不同的人编写不同的函数时，不用担心自己定义的函数，是否会与其它文件中的函数同名，因为同名也没有关系。
<2> 对函数的作用域仅局限于本文件，静态函数不能被其他文件所用。

<3>静态函数会被自动分配在一个一直使用的存储区，直到退出应用程序实例，避免了调用函数时压栈出栈，速度快很多。
 
存储说明符auto，register，extern，static，对应两种存储期：自动存储期和静态存储期。
 
auto和register对应自动存储期。具有自动存储期的变量在进入声明该变量的程序块时被建立，它在该程序块活动时存在，退出该程序块时撤销。

关键字extern和static用来说明具有静态存储期的变量和函数。用static声明的局部变量具有静态存储持续期（static storage duration），或静态范围（static extent）。虽然他的值在函数调用之间保持有效，但是其名字的可视性仍限制在其局部域内。静态局部对象在程序执行到该对象的声明处时被首次初始化。

由于static变量的以上特性，可实现一些特定功能。

统计次数功能

声明函数的一个局部变量，并设为static类型，作为一个计数器，这样函数每次被调用的时候就可以进行计数。这是统计函数被调用次数的最好的办法，因为这个变量是和函数息息相关的，而函数可能在多个不同的地方被调用，所以从调用者的角度来统计比较困难。代码如下：

#include <stdio.h>void count();int main(){    int i;    for (i = 1; i <= 3; i++)        count();    return 0;}void count(){    static int num = 0;    num++;    printf( " I have been called %d times\n", num );}

输出结果为：
 I have been called 1 times
 I have been called 2 times
 I have been called 3 times

C语言程序可以看成由一系列外部对象构成，这些外部对象可能是变量或函数。而内部变量是指定义在函数内部的函数参数及变量。外部变量定义在函数之外，因此可以在许多函数中使用。由于C语言不允许在一个函数中定义其它函数，因此函数本身只能是“外部的”。

      由于C语言代码是以文件为单位来组织的，在一个源程序所有源文件中，一个外部变量或函数只能在某个文件中定义一次，而其它文件可以通过extern声明来访问它（定义外部变量或函数的源文件中也可以包含对该外部变量的extern声明）。

      而static则可以限定变量或函数为静态存储。如果用static限定外部变量与函数，则可以将该对象的作用域限定为被编译源文件的剩余部分。通过static限定外部对象，可以达到隐藏外部对象的目的。因而，static限定的变量或函数不会和同一程序中其它文件中同名的相冲突（完成面向对象编程中private函数的功能）。如果用static限定内部变量，则该变量从程序一开始就拥有内存，不会随其所在函数的调用和退出而分配和消失。

问题：Static的理解

关于static变量，请选择下面所有说法正确的内容：
A、若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度；
B、若全局变量仅由单个函数访问，则可以将这个变量改为该函数的静态局部变量，以降低模块间的耦合度；
C、设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑重入问题；
D、静态全局变量过大，可那会导致堆栈溢出。
答案与分析：
对于A，B：根据本篇概述部分的说明b)，我们知道，A,B都是正确的。
对于C：根据本篇概述部分的说明a)，我们知道，C是正确的（所谓的函数重入问题，下面会详细阐述）。
对于D：静态变量放在程序的全局数据区，而不是在堆栈中分配，所以不可能导致堆栈溢出，D是错误的。
因此，答案是A、B、C。

问题：不可重入函数

曾经设计过如下一个函数，在代码检视的时候被提醒有bug，因为这个函数是不可重入的，为什么？

unsigned int sum_int( unsigned int base ){    unsigned int index;    static unsigned int sum = 0; // 注意，是static类型的。    for (index = 1; index <= base; index++)    {        sum += index;    }    return sum;} 

答案与分析：
所谓的函数是可重入的（也可以说是可预测的），即：只要输入数据相同就应产生相同的输出。
这个函数之所以是不可预测的，就是因为函数中使用了static变量，因为static变量的特征，这样的函数被称为：带“内部存储器”功能的的函数。因此如果我们需要一个可重入的函数，那么，我们一定要避免函数中使用static变量，这种函数中的static变量，使用原则是，能不用尽量不用。
将上面的函数修改为可重入的函数很简单，只要将声明sum变量中的static关键字去掉，变量sum即变为一个auto 类型的变量，函数即变为一个可重入的函数。
当然，有些时候，在函数中是必须要使用static变量的，比如当某函数的返回值为指针类型时，则必须是static的局部变量的地址作为返回值，若为auto类型，则返回为错指针。

面试题：

一

// test.h#ifndef __TEST_H__#define __TEST_H__static int i_val;void set_val( int val );int get_val();#endif

// test.c#include "test.h"void set_val( int val ){    i_val = val;}int get_val(){    return i_val;}

// main.c#include "stdio.h"#include "test.h"int main(){    printf( "get_val(): %d\n", get_val() );    set_val( 10 );    printf( "get_val(): %d\n", get_val() );    i_val = 20;    printf( "get_val(): %d\n", get_val() );    return 0;}

以上程序能否正常运行，如果能正常运行，输出结果是什么？

这是今天的笔试题，把我难住了

首先，直接在源文件中定义static变量和在头文件中定义static 变量有什么区别，是不是一样？

其次，main中设置了i_val这个static变量后，是否会改变它的值？

在电脑上测试了，如果使用如下命令编译通过：

gcc -g -Wall -Werror ./main.c ./test.h ./test.c -o ./static

输出结果：

get_val(): 0get_val(): 10get_val(): 10

二

再把main.c修改成如下：

// main.c#include "stdio.h"#include "test.h"int main(){    printf( "get_val(): %d\n", get_val() );    set_val( 10 );    printf( "get_val(): %d\n", get_val() );    i_val = 20;    printf( "get_val(): %d\n", get_val() );    printf( "i_val: %d\n", i_val );    return 0;}

输出结果：

get_val(): 0
get_val(): 10
get_val(): 10
i_val: 20

由于可以看出，调用get_val()和set_val函数，是引用的test.c中的i_val变量。

但是直接修改i_val，候改变的是main.c中的i_val。

三

再次修改程序，把静态变量定义到.c文件中：

// test.h#ifndef __TEST_H__#define __TEST_H__//static int i_val;void set_val( int val );int get_val();#endif

// test.c#include "test.h"static int i_val;void set_val( int val ){    i_val = val;}int get_val(){    return i_val;}

// test1.h#ifndef __TEST1_H__#define __TEST1_H__void staticval_test();#endif

// test1.c#include "stdio.h"#include "test1.h"#include "test.h"void staticval_test(){    printf( "test1.c get_val(): %d\n", get_val() );    set_val( 30 );    printf( "test1.c get_val(): %d\n", get_val() );    set_val( 40 );    printf( "test1.c get_val(): %d\n", get_val() );}

// main.c#include "stdio.h"#include "test.h"#include "test1.h"int main(){    printf( "get_val(): %d\n", get_val() );    set_val( 10 );    printf( "get_val(): %d\n", get_val() );    set_val( 20 );    printf( "get_val(): %d\n", get_val() );    staticval_test();    printf( "get_val(): %d\n", get_val() );    return 0;}

输出结果：

get_val(): 0
get_val(): 10
get_val(): 20
test1.c get_val(): 20
test1.c get_val(): 30
test1.c get_val(): 40
get_val(): 40

这一次，main.c和test1.c中，都是调用的test.c中的静态变量了。

所以，由于头文件是被直接嵌入到包含它的源文件中的，那么定义在头文件中的静态变量，由于静太全局变量的文件作用域，在包含它的不同的源文件中，不是同一个变量。

定义在源文件中的全局静态变量，作用域是这个源文件。其它源文件通过函数调用来使用这个源文件中的静态变量，就可以做到在不同的源文件中使用同一个静态变量。

作为对比，下面使用正确的方式来定义全局变量：

1

2

3

4

//Header.h

#pragma once

 

extern int g_int;

1

2

3

4

5

6

7

8

9

10

11

12

//Source1.cpp

#include <stdio.h>

#include "Header.h"

 

int g_int = 3;

 

void TestSource1() {

 

    wprintf(L"g_int's address in Source1.cpp: %08x\n", &g_int);

    g_int = 5;

    wprintf(L"g_int's value in Source1.cpp: %d\n", g_int);

}

 

其它文件不变。

 

运行程序：

可以看到，这次两个源文件中使用的都是同一个变量。

要注意的是，使用extern声明变量时不能带有初始值，否则仍然属于变量定义，会出现变量重定义的错误。