C语言中变量的作用域

C语言中变量的作用域

C

语言中变量的作用域


C

语言中所有变量都有自己的作用域，申明变量的类型不同，其作用域也不同。
C

语言中的变量，按照作用域的范围可分为两种，

即局部变量和全局变量。



一、局部变量

局部变量也称为内部变量。局部变量是在函数内作定义说明的。其作用域仅限于函数内，

离开该函数后再使用这种变量是非法的。

例如：

int f1(int a) /* 函数 f1*/ { int b,c ； …… }	int f2(int x) /* 函数 f2*/ { int y,z; ； …… }
f1 内定义了三个变量， a 为形参， b,c 为一般变量。在 f1 的范围内 a,b,c 有效，或者说 a,b,c 变量的作用域限于 f1 内。	f2 内定义了三个变量， x 为形参， y,z 为一般变量。在 f2 的范围内 x,y,z 有效，或者说 x,y,z 变量的作用域限于 f2 内。

关于局部变量的作用域还要说明以下几点：





主函数中定义的变量也只能在主函数中使用，不能在其它函数中使用。同时，主函数中也不能使用其它函数中定义的变量。因为主函数也是一个函数，它与其它函数是平行关系。





形参变量是属于被调函数的局部变量，实参变量是属于主调函数的局部变量。





允许在不同的函数中使用相同的变量名，它们代表不同的对象，分配不同的单元，互不干扰，也不会发生混淆。虽然允许在不同的函数中使用相同的变量名，但是为了使程序明了易懂，不提倡在不同的函数中使用相同的变量名。

二、全局变量

int a,b; /* 外部变量 */ void f1() /* 函数 f1*/ { …… }

float x,y; /* 外部变量 */ int fz() /* 函数 fz*/ { …… }

全局变量也称为外部变量，它是在函数外部定义的变量。

它不属于哪一个函数，它属于一个源程序文件。其作用域是整个源程序。在函数中使用全局变量，一般应作全局变量说明。

只有在函数内经过说明的全局变量才能使用。全局变量的说明符为
extern

。

但在一个函数之前定义的全局变量，在该函数内使用可不再加以说明。

例如：


　　从上例可以看出
a

、
b

、
x

、
y

都是在函数外部定义的外部变量，都是全局变量。

　　对于全局变量还有以下几点说明：






对于局部变量的定义和说明，可以不加区分。而对于外部变量则不然，外部变量的定义和外部变量的说明并不是一回事。外部变量定义必须在所有的函数之外，且只能定义一次。其一般形式为：
[extern]

类型说明符

变量名，变量名
…

其中方括号内的
extern

可以省去不写。


　　

例如：

int a,b;

　　

等效于：


　　

extern int a,b;

　　

而外部变量说明出现在要使用该外部变量的各个函数内，在整个程序内，可能出现多次，外部变量说明的一般形式为：
extern

类型说明符

变量名，变量名，
…

；

外部变量在定义时就已分配了内存单元，外部变量定义可作初始赋值，外部变量说明不能再赋初始值，

只是表明在函数内要使用某外部变量。





外部变量可加强函数模块之间的数据联系，但是又使函数要依赖这些变量，因而使得函数的独立性降低。从模块化程序设计的观点来看这是不利的，

因此在不必要时尽量不要使用全局变量。





在同一源文件中，允许全局变量和局部变量同名。在局部变量的作用域内，全局变量不起作用。


int vs(int l,int w)

{

extern int h;

int v;

v=l*w*h;

return v;

}

main()

{

extern int w,h;

int l=5;

printf("v=%d",vs(l,w));

}

int l=3,w=4,h=5;

　　

本例程序中，外部变量在最后定义，

因此在前面函数中对要用的外部变量必须进行说明。外部变量
l

，
w

和
vs

函数的形参
l

，
w

同名。外部变量都作了初始赋值，
mian

函数中也对
l

作了初始化赋值。执行程序时，在
printf

语句中调用
vs

函数，实参
l

的值应为
main

中定义的
l

值，等于
5

，外部变量
l

在
main

内不起作用；实参
w

的值为外部变量
w

的值为
4

，进入
vs

后这两个值传送给形参
l

，
wvs

函数中使用的
h

为外部变量，其值为
5

，因此
v

的计算结果为
100

，返回主函数后输出。

变量的存储类型决定了各种变量的作用域不同。所谓存储类型是指变量占用内存空间的方式，也称为存储方式。变量的存储方式可分为
“

静态存储
”

和
“

动态存储
”

两种。


　　

静态存储变量通常是在变量定义时就分定存储单元并一直保持不变，

直至整个程序结束。动态存储变量是在程序执行过程中，使用它时才分配存储单元，

使用完毕立即释放。

典型的例子是函数的形式参数，在函数定义时并不给形参分配存储单元，只是在函数被调用时，才予以分配，

调用函数完毕立即释放。如果一个函数被多次调用，则反复地分配、

释放形参变量的存储单元。从以上分析可知，

静态存储变量是一直存在的，

而动态存储变量则时而存在时而消失。我们又把这种由于变量存储方式不同而产生的特性称变量的生存期。

生存期表示了变量存在的时间。

生存期和作用域是从时间和空间这两个不同的角度来描述变量的特性，这两者既有联系，又有区别。

一个变量究竟属于哪一种存储方式，

并不能仅从其作用域来判断，还应有明确的存储类型说明。

在
C

语言中，对变量的存储类型说明有以下四种：

auto

　　　　

自动变量



　　
register

　　

寄存器变量



　　
extern

　　　外部变量



　　
static

　　　静态变量


　　

自动变量和寄存器变量属于动态存储方式，外部变量和静态变量属于静态存储方式。在介绍了变量的存储类型之后，

可以知道对一个变量的说明不仅应说明其数据类型，还应说明其存储类型。

因此变量说明的完整形式应为：

存储类型说明符

数据类型说明符

变量名，变量名
…

；

例如：


　　
static int a,b;

　　　　　　　　　

说明
a,b

为静态类型变量



　　
auto char c1,c2;

　　　　　　　　　说明
c1,c2

为自动字符变量



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

　　　说明
a

为静整型数组



　　
extern int x,y;

　　　　　　　　　

说明
x,y

为外部整型变量



　　

下面分别介绍以上四种存储类型：


　　

一、自动变量的类型说明符为

auto

　　

这种存储类型是
C

语言程序中使用最广泛的一种类型。
C

语言规定，

函数内凡未加存储类型说明的变量均视为自动变量，

也就是说自动变量可省去说明符
auto

。

在前面各章的程序中所定义的变量凡未加存储类型说明符的都是自动变量。例如：



{ int i,j,k;

char c;

……

}

等价于：

{ auto int i,j,k;

auto char c;

……

}

　　

自动变量具有以下特点：


　　
1.

自动变量的作用域仅限于定义该变量的个体内。在函数中定义的自动变量，只在该函数内有效。在复合语句中定义的自动变量只在该复合语句中有效。

例如：


int kv(int a)

{

auto int x,y;

{ auto char c;

} /*c

的作用域

*/

……

} /*a,x,y

的作用域

*/

　　
2.

自
动变量属于动态存储方式，只有在使用它，即定义该变量的函数被调用时才给它分配存储单元，开始它的生存期。函数调用结束，释放存储单元，结束生存期。因此
函数调用结束之后，自动变量的值不能保留。在复合语句中定义的自动变量，在退出复合语句后也不能再使用，否则将引起错误。例如以下程序：


main()

{ auto int a,s,p;

printf("/ninput a number:/n");

scanf("%d",&a);

if(a>0){

s=a+a;

p=a*a;

}

printf("s=%d p=%d/n",s,p);

}

{ auto int a;

printf("/ninput a number:/n");

scanf("%d",&a);

if(a>0){

auto int s,p;

s=a+a;

p=a*a;

}

printf("s=%d p=%d/n",s,p);

}

　　
s,p

是在复合语句内定义的自动变量，只能在该复合语句内有效。而程序的第
9

行却是退出复合语句之后用
printf

语句输出
s,p

的值，这显然会引起错误。


　　
3.

由于自动变量的作用域和生存期都局限于定义它的个体内
(

函数或复合语句内
)

，

因此不同的个体中允许使用同名的变量而不会混淆。

即使在函数内定义的自动变量也可与该函数内部的复合语句中定义的自动变量同名。例
5.14

表明了这种情况。


main()

{

auto int a,s=100,p=100;

printf("/ninput a number:/n");

scanf("%d",&a);

if(a>0)

{

auto int s,p;

s=a+a;

p=a*a;

printf("s=%d p=%d/n",s,p);

}

printf("s=%d p=%d/n",s,p);

}

　　

本程序在
main

函数中和复合语句内两次定义了变量
s,p

为自动变量。按照
C

语言的规定，在复合语句内，应由复合语句中定义的
s,p

起作用，故
s

的值应为
a+ a

，
p

的值为
a*a

。退出复合语句后的
s,p

应为
main

所定义的
s,p

，其值在初始化时给定，均为
100

。从输出结果可以分析出两个
s

和两个
p

虽变量名相同，

但却是两个不同的变量。


　　
4.

对构造类型的自动变量如数组等，不可作初始化赋值。


　　

二、外部变量的类型说明符为

extern

　　

在前面介绍全局变量时已介绍过外部变量。这里再补充说明外部变量的几个特点：


　　
1.

外部变量和全局变量是对同一类变量的两种不同角度的提法。全局变量是从它的作用域提出的，外部变量从它的存储方式提出的，表示了它的生存期。


　　
2.

当一个源程序由若干个源文件组成时，

在一个源文件中定义的外部变量在其它的源文件中也有效。例如有一个源程序由源文件
F1.C

和
F2.C

组成：

F1.C

int a,b; /*

外部变量定义

*/

char c; /*

外部变量定义

*/

main()

{

……

}

　　

F2.C

extern int a,b; /*

外部变量说明

*/

extern char c; /*

外部变量说明

*/

func (int x,y)

{

……

}

　　

在
F1.C

和
F2.C

两个文件中都要使用
a,b,c

三个变量。在
F1.C

文件中把
a,b,c

都定义为外部变量。在
F2.C

文件中用
extern

把三个变量说明为外部变量，表示这些变量已在其它文件中定义，并把这些变量的类型和变量名，编译系统不再为它们分配内存空间。

对构造类型的外部变量，

如数组等可以在说明时作初始化赋值，若不赋初值，则系统自动定义它们的初值为
0

。


静态变量


　　

静态变量的类型说明符是
static

。

静态变量当然是属于静态存储方式，但是属于静态存储方式的量不一定就是静态变量，

例如外部变量虽属于静态存储方式，但不一定是静态变量，必须由
static

加以定义后才能成为静态外部变量，或称静态全局变量。

对于自动变量，前面已经介绍它属于动态存储方式。

但是也可以用
static

定义它为静态自动变量，或称静态局部变量，从而成为静态存储方式。



由此看来，

一个变量可由
static

进行再说明，并改变其原有的存储方式。


　　
1.

静态局部变量


　　

在局部变量的说明前再加上
static

说明符就构成静态局部变量。


　　

例如：


static int a,b;

static float array[5]={1,2,3,4,5}

；


　　

静态局部变量属于静态存储方式，它具有以下特点：


　　
(1)

静态局部变量在函数内定义，但不象自动变量那样，当调用时就存在，退出函数时就消失。静态局部变量始终存在着，也就是说它的生存期为整个源程序。


　　
(2)

静态局部变量的生存期虽然为整个源程序，但是其作用域仍与自动变量相同，即只能在定义该变量的函数内使用该变量。退出该函数后，

尽管该变量还继续存在，但不能使用它。


　　
(3)

允许对构造类静态局部量赋初值。在数组一章中，介绍数组初始化时已作过说明。若未赋以初值，则由系统自动赋以
0

值。


　　
(4)

对基本类型的静态局部变量若在说明时未赋以初值，则系统自动赋予
0

值。而对自动变量不赋初值，则其值是不定的。

根据静态局部变量的特点，

可以看出它是一种生存期为整个源程序的量。虽然离开定义它的函数后不能使用，但如再次调用定义它的函数时，它又可继续使用，

而且保存了前次被调用后留下的值。

因此，当多次调用一个函数且要求在调用之间保留某些变量的值时，可考虑采用静态局部变量。虽然用全局变量也可以达到上述目的，但全局变量有时会造成意外的副作用，因此仍以采用局部静态变量为宜。



　　
[

例

5.15]

main()

{

int i;

void f(); /*

函数说明

*/

for(i=1;i<=5;i++)

f(); /*

函数调用

*/

}

void f() /*

函数定义

*/

{

auto int j=0;

++j;

printf("%d/n",j);

}

　　

程序中定义了函数
f

，其中的变量
j

说明为自动变量并赋予初始值为
0

。当
main

中多次调用
f

时，
j

均赋初值为
0

，故每次输出值均为
1

。现在把
j

改为静态局部变量，程序如下：


main()

{

int i;

void f();

for (i=1;i<=5;i++)

f();

}

void f()

{

static int j=0;

++j;

printf("%d/n",j);

}

void f()

{

static int j=0;

++j;

printf("%d/n",j);

}

　　

由于
j

为静态变量，能在每次调用后保留其值并在下一次调用时继续使用，所以输出值成为累加的结果。读者可自行分析其执行过程。


　　
2.

静态全局变量


　　

全局变量
(

外部变量
)

的说明之前再冠以
static

就构成了静态的全局变量。全局变量本身就是静态存储方式，

静态全局变量当然也是静态存储方式。

这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序，

当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。

而静态全局变量则限制了其作用域，

即只在定义该变量的源文件内有效，

在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，

因此可以避免在其它源文件中引起错误。从以上分析可以看出，

把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，

限制了它的使用范围。因此
static

这个说明符在不同的地方所起的作用是不同的。应予以注意。


　　

四、寄存器变量


　　

上述各类变量都存放在存储器内，

因此当对一个变量频繁读写时，必须要反复访问内存储器，从而花费大量的存取时间。

为此，
C

语言提供了另一种变量，即寄存器变量。这种变量存放在
CPU

的寄存器中，使用时，不需要访问内存，而直接从寄存器中读写，

这样可提高效率。寄存器变量的说明符是
register

。

对于循环次数较多的循环控制变量及循环体内反复使用的变量均可定义为寄存器变量。


求

∑200i=1imain()

{

register i,s=0;

for(i=1;i<=200;i++)

s=s+i;

printf("s=%d/n",s);

}

　　

本程序循环
200

次，
i

和
s

都将频繁使用，因此可定义为寄存器变量。对寄存器变量还要说明以下几点：


　　
1.

只有局部自动变量和形式参数才可以定义为寄存器变量。因为寄存器变量属于动态存储方式。凡需要采用静态存储方式的量不能定义为寄存器变量。


　　
2.

在
Turbo C

，
MS C

等微机上使用的
C

语言中，

实际上是把寄存器变量当成自动变量处理的。因此速度并不能提高。

而在程序中允许使用寄存器变量只是为了与标准
C

保持一致。
3.

即使能真正使用寄存器变量的机器，由于
CPU

中寄存器的个数是有限的，因此使用寄存器变量的个数也是有限的。

c语言中的static

网上的几个介绍，引用在这里
static关键字是C, C++中都存在的关键字, 它主要有三种使用方式, 其中前两种在C/C++语言中使用, 第三种只在C++中使用(C,C++中具体细微操作不尽相同, 本文以C++为准).

(1)局部静态变量

(2)外部静态变量/函数

(3)静态数据成员/成员函数

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

一、局部静态变量

在C/C++中, 局部变量按照存储形式可分为三种auto, static, register

(<C语言程序设计(第二版)>谭浩强, 第174-175页)

与auto类型(普通)局部变量相比, static局部变量有三点不同

1. 存储空间分配不同

auto类型分配在栈上, 属于动态存储类别, 占动态存储区空间, 函数调用结束后自动释放, 而static分配在静态存储区, 在程序整个运行期间都不释放. 两者之间的作用域相同, 但生存期不同.

2. static局部变量在所处模块在初次运行时进行初始化工作, 且只操作一次

3. 对于局部静态变量, 如果不赋初值, 编译期会自动赋初值0或空字符, 而auto类型的初值是不确定的. (对于C++中的class对象例外, class的对象实例如果不初始化, 则会自动调用默认构造函数, 不管是否是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的作用, 延长变量的生存期.

示例程序二:

// IP address to string format

// Used in Ethernet Frame and IP Header analysis

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;

}

注意事项:

1. “记忆性”, 程序运行很重要的一点就是可重复性, 而static变量的”记忆性”破坏了这种可重复性, 造成不同时刻至运行的结果可能不同.

2.
“生存期”全局性和唯一性. 普通的local变量的存储空间分配在stack上, 因此每次调用函数时, 分配的空间都可能不一样,
而static具有全局唯一性的特点, 每次调用时, 都指向同一块内存, 这就造成一个很重要的问题 ---- 不可重入性!!!

这样在多线程程序设计或递归程序设计中, 要特别注意这个问题.

(不可重入性的例子可以参见<effective C++ (2nd)>(影印版)第103-105页)

下面针对示例程序二, 分析在多线程情况下的不安全性.(为方便描述, 标上行号)

① 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使得函数成为静态函数。但此处“static”的含义不是指存储方式，而是指对函数的作用域仅局限于本文件(所以又称内部函
数)。注意此时, 对于外部(全局)变量, 不论是否有static限制, 它的存储区域都是在静态存储区, 生存期都是全局的.
此时的static只是起作用域限***用, 限定作用域在本模块(文件)内部.

使用内部函数的好处是：不同的人编写不同的函数时，不用担心自己定义的函数，是否会与其它文件中的函数同名。

示例程序三:



//file1.cpp

static int varA;

int varB;

extern void funA()

{

……

}

static void funB()

{

……

}

//file2.cpp

extern int varB; // 使用file1.cpp中定义的全局变量

extern int varA; // 错误! varA是static类型, 无法在其他文件中使用

extern vod funA(); // 使用file1.cpp中定义的函数

extern void funB(); // 错误! 无法使用file1.cpp文件中static函数


三、静态数据成员／成员函数(C++特有)

C++重用了这个关键字，并赋予它与前面不同的第三种含义：
表示属于一个类而不是属于此类的任何特定对象的变量和函数. 这是与普通成员函数的最大区别, 也是其应用所在, 比如在对某一个类的对象进行计数时,
计数生成多少个类的实例, 就可以用到静态数据成员. 在这里面, static既不是限定作用域的, 也不是扩展生存期的作用,
而是指示变量/函数在此类中的唯一性. 这也是”属于一个类而不是属于此类的任何特定对象的变量和函数”的含义. 因为它是对整个类来说是唯一的,
因此不可能属于某一个实例对象的. (针对静态数据成员而言, 成员函数不管是否是static, 在内存中只有一个副本, 普通成员函数调用时,
需要传入this指针, static成员函数调用时, 没有this指针. )

请看示例程序四(<effective c++ (2nd)>(影印版)第59页)

class EnemyTarget {

public:

EnemyTarget() { ++numTargets; }

EnemyTarget(const EnemyTarget&) { ++numTargets; }

~EnemyTarget() { --numTargets; }

static size_t numberOfTargets() { return numTargets; }

bool destroy(); // returns success of attempt to destroy EnemyTarget object

private:

static size_t numTargets; // object counter

};

// class statics must be defined outside the class;

// initialization is to 0 by default

size_t EnemyTarget::numTargets;

在这个例子中, 静态数据成员numTargets就是用来计数产生的对象个数的.

另外, 在设计类的多线程操作时, 由于POSIX库下的线程函数pthread_create()要求是全局的, 普通成员函数无法直接做为线程函数, 可以考虑用Static成员函数做线程函数.


【我解C语言面试题系列】001 static有什么用途？

【题目】
static
有什么用途？



在网上流传很广的一个答案是：

1、限制变量的作用域

2、设置变量的存储域


我觉得这样答题是不妥当的，有点文不对题的感觉。



下面是我给出的答案：

static

类型声明符在
C
语言里面主要有三个用途：

<!--[if !supportLists]-->1、

<!--[endif]-->声明静态局部变量。

<!--[if !supportLists]-->2、

<!--[endif]-->声明静态外部全局变量。

<!--[if !supportLists]-->3、

<!--[endif]-->声明静态外部函数。



下面是我整理的有关上面三个用法的解释说明。另外网友
xiaocai0001
的《
static
用法小结》一文有更详细的解释，请参考。


http://blog.csdn.net/xiaocai0001/archive/2006/04/14/662921.aspx

静态局部变量

（与
auto
对比）


<!--[if !supportLists]-->1、


<!--[endif]-->存储空间分配、作用域和生存期


static
分配在静态存储区，作用域仅仅限于声明该变量的函数内部。在程序

整个运行期间都不释放，生存期贯穿于程序运行的整个过程。

auto
类型分配在栈上，属于动态存储类别，占动态存储区空间，作用域仅仅限于声明该变量的函数内部。函数调用结束后自动释放，生存期不过是在声明该变量的函数内部。

2

、赋初值时的处理方式


static
静态局部变量在编译时赋初值，即只赋初值一次；

auto
自动变量赋初值是在函数调用时进行，每调用一次函数重新给一次初值，相当于执行一次赋值语句。

3

、未赋初值时的处理方式


如果在定义局部变量时不赋初值的话：

static
静态局部变量，编译时自动赋初值
0
（对数值型变量）或空字符（对字符变量）。

auto
自动变量，如果不赋初值则它的值是一个不确定的值。



静态外部全局变量


在
C
语言中
static
还用来声明静态外部全局变量，那么这个全局变量的作用域就被限制在本文件内部。

外部变量（即全局变量）是在函数的外部定义的，它的作用域为从变量定义处开始，到本程序文件的末尾。如果外部变量不在文件的开头定义，其有效的作用范围只限于定义处到文件终了。如果在定义点之前的函数想引用该外部变量，则应该在引用之前用关键字
extern
对该变量作“外部变量声明”。表示该变量是一个已经定义的外部变量。有了此声明，就可以从“声明”处起，合法地使用该外部变量。

而如果我们声明的全局变量不想被其他文件访问和使用又该怎么办？

那就是在声明的时候前面加上关键字
static
。



静态外部函数




在
C
语言中我们的函数默认都是全局的，也就是说你可以调用其他文件中的函数。在使用的时候，我们象前面一样在头文件中加上
extern
就可以了。但是有时候我们写的函数并不想让别的文件访问和调用，那么我们在声明函数的时候前面加上
static
就可以了。

使用内部函数的好处有二：

1
、可以让某些内部函数不为人所能使用，而仅仅让调用者使用他能使用的东西，有利于保护代码。

2
、不同的人编写不同的函数时，不用担心自己定义的函数，是否会与其它文件中的函数同名。