对于我这样的C语言新手来说这个知识点 今天才真正弄明白。

! L! f0 S. I# }8 N9 M    弄懂static 对于写大型的c语言程序还是有很大的帮助。
6 d( O  m! W. k6 w) F( K+ I
     原文地址：
     http://blog.csdn.net/keyeagle/article/details/6708077
' a6 A, D& x6 f! ]
2 \* _7 G+ }& a/ F4 f* o7 \+ `

      google了近三页的关于C语言中static的内容，发现可用的信息很少，要么长篇大论不知所云要么在关键之处几个字略过，对于想挖掘底层原理的初学者来说参考性不是很大。所以，我这篇博文博采众家之长，把互联网上的资料整合归类，并亲手编写程序验证之。

         C语言代码是以文件为单位来组织的，在一个源程序的所有源文件中，一个外部变量（注意不是局部变量）或者函数只能在一个源程序中定义一次，如果有重复定义的话编译器就会报错。伴随着不同源文件变量和函数之间的相互引用以及相互独立的关系，产生了extern和static关键字。

        下面，详细分析一下static关键字在编写程序时有的三大类用法：

        一，static全局变量

           我们知道，一个进程在内存中的布局如图1所示：

      其中.text段保存进程所执行的程序二进制文件，.data段保存进程所有的已初始化的全局变量，.bss段保存进程未初始化的全局变量（其他段中还有很多乱七八糟的段，暂且不表）。在进程的整个生命周期中，.data段和.bss段内的数据时跟整个进程同生共死的，也就是在进程结束之后这些数据才会寿终就寝。

     当一个进程的全局变量被声明为static之后，它的中文名叫静态全局变量。静态全局变量和其他的全局变量的存储地点并没有区别，都是在.data段（已初始化）或者.bss段（未初始化）内，但是它只在定义它的源文件内有效，其他源文件无法访问它。所以，普通全局变量穿上static外衣后，它就变成了新娘，已心有所属，只能被定义它的源文件（新郎）中的变量或函数访问。

以下是一些示例程序

7 y' {" J! f  t6 L6 s

file1.h如下：

1. #include <stdio.h>
   
2. 
   
3. void printStr();

复制代码

我们在file1.c中定义一个静态全局变量hello, 供file1.c中的函数printStr访问.

1. #include "file1.h"
   
2. 
   & j' J4 s6 f7 }0 o( K; [3 M
3. static char* hello = "hello cobing!";
   1 Q9 k0 U8 ~$ ^/ }! z1 y: L$ I7 Y$ s
4. 
   
5. void printStr()
   0 E# ~8 j  D& P$ O
6. {
   . y) i+ P5 V5 X8 c- Z/ s
7.         printf("%s\n", hello);
   
8. }
   / i6 y( Z4 w' Z, E+ b) V

复制代码

file2.c是我们的主程序所在文件，file2.c中如果引用hello会编译出错

1. #include "file1.h"
   
2. 
   ( |& X3 H% s$ z; [7 X7 |
3. int main()
   2 l9 p# ?) M3 g- o
4. {
   7 N/ z  n! I" L6 [; ~6 l
5.         printStr();
   
6.         printf("%s\n", hello);
   
7.         return 0;
   
8. }

复制代码

报错如下：

[liujx@server235 static]$ gcc -Wall file2.c file1.c -o file2
7 m3 Q% e9 Y* b  D9 Z3 ?file2.c: In function ‘main’:
' _4 Y! Y% a" X" J+ o4 Dfile2.c:6: 错误：‘hello’ 未声明 (在此函数内第一次使用)
" x2 P0 A! a2 N, q8 n! Q6 m1 U8 qfile2.c:6: 错误：(即使在一个函数内多次出现，每个未声明的标识符在其
file2.c:6: 错误：所在的函数内只报告一次。)

6 _/ s, k( D9 D' M0 p2 j4 E! Q; Q

如果我们将file2.c改为下面的形式：

1. #include "file1.h"
   
2. 
   + F% _- T' R! {) i  V. O1 C& w
3. int main()
   9 G4 q* k/ B: i! K& r+ M1 ^  K) E  h
4. {
   
5.         printStr();
   0 F3 n3 U2 d/ F" S+ r
6.         return 0;
   
7. }
   

复制代码

则会顺利编译连接。

运行程序后的结果如下：
[liujx@server235 static]$ gcc -Wall file2.c file1.c -o file2
[liujx@server235 static]$ ./file2
/ S3 @" a  L& G* C4 S+ {hello cobing!

上面的例子中，file1.c中的hello就是一个静态全局变量，它可以被同一文件中的printStr调用，但是不能被不同源文件中的file2.c调用。

二，static局部变量

      普通的局部变量在栈空间上分配，这个局部变量所在的函数被多次调用时，每次调用这个局部变量在栈上的位置都不一定相同。局部变量也可以在堆上动态分配，但是记得使用完这个堆空间后要释放之。

       static局部变量中文名叫静态局部变量。它与普通的局部变量比起来有如下几个区别：

           1）位置：静态局部变量被编译器放在全局存储区.data（注意：不在.bss段内，原因见3）），所以它虽然是局部的，但是在程序的整个生命周期中存在。

           2）访问权限：静态局部变量只能被其作用域内的变量或函数访问。也就是说虽然它会在程序的整个生命周期中存在，由于它是static的，它不能被其他的函数和源文件访问。

           3）值：静态局部变量如果没有被用户初始化，则会被编译器自动赋值为0，以后每次调用静态局部变量的时候都用上次调用后的值。这个比较好理解，每次函数调用静态局部变量的时候都修改它然后离开，下次读的时候从全局存储区读出的静态局部变量就是上次修改后的值。
以下是一些示例程序：

     file1.h的内容和上例中的相同，file1.c的内容如下：

1. #include "file1.h"
   
2. 
   + M" J0 H% ?- g) w
3. void printStr()
   
4. {
   
5.         int normal = 0;
   
6.         static int stat = 0;        //this is a static local var
   5 g: O! v( M0 w4 k4 x  G5 [2 d
7.         printf("normal = %d ---- stat = %d\n",normal, stat);
     a' g5 N; Q# a# z, t
8.         normal++;
   
9.         stat++;
   * J6 E3 a( y3 G7 \
10. }

复制代码

为了便于比较，我定义了两个变量：普通局部变量normal和静态局部变量stat，它们都被赋予初值0；

file2.c中调用file1.h：

1. #include "file1.h"
   4 K  x: g; O* a/ k" u' C. ~
2. 
   . q' y2 J3 q" {6 i  B/ Q
3. int main()
   
4. {
   9 s% ^5 b  i2 x8 @
5. printStr();
   
6. printStr();
   9 j+ `' ?0 |% `$ z% N" d$ O8 U
7. printStr();
   
8. printStr();
   $ i) W! {( }4 f' d1 y) n$ J4 V/ M4 q
9. printf("call stat in main: %d\n",stat);
   
10. return 0;
    . s1 `8 Z% W3 t7 S* Y
11. }
    

复制代码

这个调用会报错，因为file2.c中引用了file1.c中的静态局部变量stat，如下：

[liujx@server235 static]$ gcc -Wall file2.c file1.c -o file2
file2.c: In function ‘main’:
, ]0 a! {% c2 [file2.c:9: 错误：‘stat’ 未声明 (在此函数内第一次使用)
/ ^7 @( i) ?; {: T3 t4 G+ e$ k( nfile2.c:9: 错误：(即使在一个函数内多次出现，每个未声明的标识符在其
' G' t; {* J6 N0 `file2.c:9: 错误：所在的函数内只报告一次。)

编译器说stat未声明，这是因为它看不到file1.c中的stat，下面注掉这一行：

1. #include "file1.h"
   4 E% C* l+ n0 j; p) o* b% U
2. 
   
3. int main()
   
4. {
   
5.         printStr();
   
6.         printStr();
   
7.         printStr();
   % ~- {8 o' z3 x7 B, O# U8 y
8.         printStr();
   
9. //        printf("call stat in main: %d\n",stat);
   4 e0 D7 z# o+ n2 R: }  [4 b8 Q  e& z
10.         return 0;
    
11. }
    

复制代码

liujx@server235 static]$ gcc -Wall file2.c file1.c -o file2
[liujx@server235 static]$ ./file2
normal = 0 ---- stat = 0
normal = 0 ---- stat = 1
# z: E+ u2 s* W, ]' W. I  t% i1 Hnormal = 0 ---- stat = 2
5 X4 z% \. V; L) v; a0 t" w- i: rnormal = 0 ---- stat = 3
运行如上所示。可以看出，函数每次被调用，普通局部变量都是重新分配，而静态局部变量保持上次调用的值不变。

需要注意的是由于static局部变量的这种特性，使得含静态局部变量的函数变得不可重入，即每次调用可能会产生不同的结果。这在多线程编程时可能会成为一种隐患。需要多加注意。

三，static函数
              相信大家还记得C++面向对象编程中的private函数，私有函数只有该类的成员变量或成员函数可以访问。在C语言中，也有“private函数”，它就是接下来要说的static函数，完成面向对象编程中private函数的功能。

            当你的程序中有很多个源文件的时候，你肯定会让某个源文件只提供一些外界需要的接口，其他的函数可能是为了实现这些接口而编写，这些其他的函数你可能并不希望被外界（非本源文件）所看到，这时候就可以用static修饰这些“其他的函数”。

           所以static函数的作用域是本源文件，把它想象为面向对象中的private函数就可以了。

下面是一些示例：

file1.h如下：

1. #include <stdio.h>
   
2. 
   
3. static int called();
   % c, t# e1 X$ z9 `0 W1 b9 m2 }
4. void printStr();

复制代码

file1.c如下：

1. #include "file1.h"
   
2. 
   
3. static int called()
   ( M; A; H& `. {% c
4. {
   1 w/ g, v7 _4 r" p' j: N7 ?
5.         return 6;
   % A( R8 Q/ z& g) ~; n4 H0 o, t
6. }
   # e9 C1 {1 e0 Q4 r& c& ]
7. void printStr()
   6 O% H) g7 ~/ |- S- q
8. {
   
9.         int returnVal;
   
10.         returnVal = called();
    
11.         printf("returnVal=%d\n",returnVal);
    ' R3 L; i+ x& {6 c* h
12. }
    : w6 u- }# C3 V' ]3 Z

复制代码

file2.c中调用file1.h中声明的两个函数，此处我们故意调用called():

1. #include "file1.h"
   
2. 
   . F8 E5 X' Z- y* I2 O/ T* W6 M
3. int main()
   
4. {
   . K7 R3 n* W& d2 {. _/ z
5.         int val;
   ! W7 K/ N+ `& W# W9 Q; E- j
6.         val = called();
   
7.         printStr();
   7 N- w8 Y1 [2 @7 s! L" Q
8.         return 0;
   
9. }

复制代码

编译时会报错：

[liujx@server235 static]$ gcc -Wall file2.c file1.c -o file2
file1.h:3: 警告：‘called’ 使用过但从未定义
/tmp/ccyLuBZU.o: In function `main':
file2.c.text+0x12): undefined reference to `called'
collect2: ld 返回 1
因为引用了file1.h中的static函数，所以file2.c中提示找不到这个函数:undefined reference to 'called'

下面修改file2.c:

1. #include "file1.h"
   
2. 
   
3. int main()
   
4. {
   
5.         printStr();
   
6.         return 0;
   ) d4 ^% t  ^2 [- Y
7. }

复制代码

编译运行：

[liujx@server235 static]$ gcc -Wall file2.c file1.c -o file2
. G) S0 f; J9 C: x[liujx@server235 static]$ ./file2
returnVal=6
$ r8 Q+ {. d2 a- ~" e

       static函数可以很好地解决不同原文件中函数同名的问题，因为一个源文件对于其他源文件中的static函数是不可见的。

% o8 g8 j3 G8 r7 ~$ u2 P1 `

必须好                        

nongchaoer2010 发表于 2015-12-10 09:16
! u- R0 G' d' R1 w感谢楼主分享，有了更深的认识

) r! A& _$ E5 \  \* z% b感谢支持

感谢楼主分享，有了更深的认识

谢谢分享

感谢分享，收藏学习！

留个脚印

学习一下

多谢分享

mark一下，先收藏了。

讲得挺全面

学习了，感谢分享！

感谢各位

多谢分享，不错。。

谢谢分享