一句话概括作用域：变量和函数的可访问范围
 
作用域分为三种：全局作用域（全局变量），局部作用域（局部变量），块级作用域（es6新增）
 
什么是全局变量（在函数外定义的变量）
 什么是局部变量：局部变量也叫函数变量（在函数内定义的变量）；
 
全局变量和局部变量的区别有以下几点：
 
作用域不同：全局变量的作用域为整个程序，而局部变量的作用域为当前函数
内存存储方式不同：全局变量是程序是整个程序都需要用到的，单独分出一块存储区保存，该存储区存储的数据不清空，局部变量是函数退出时自动清空的，所以放在栈里做临时存储
生命周期不同：全局变量随着程序结束而销毁，局部变量随着函数退出而销毁
 
全局变量：能不用全局变量就不用，why?
 主要原因就是 不利于模块化 因为全局变量可以被每个函数调用，可能不经意的修改就影响到其他函数，
 可复用开发麻烦。
 调试起来也麻烦，毕竟全局变量一直在变
 
var num=1;
if(1==1){
    var num=2;
    console.log(num)//2
}
console.log(num)//2
 
如果非要用到全局变量，解决方法：
 1.全局变量前面都加上 g_；
 2.全局变量只有一个，要用就只用定义好的这个
 
(function (){
    this.global=function(){}
    global.qq='1278125909';
    global.fn=function(){
        return '31'
    }
}).call(this)
console.log(global.qq)//1278125909
console.log(global.fn())//31
 
必须掌握
 
局部变量是无法被 局部变量外的函数所调用的,但是全局变量可以被局部函数所调用；
 
var num='99';
function fn1() {
    var str="cx";
    console.log(num);//99
}
fn1()
console.log(str)// str is not defined
 
 
1 .在函数体内，局部变量的优先级高于同名的全局变量，如果重名，全局变量会被覆盖
 
var scope="global";
function fn() {
    var scope="func";
    return scope
}
console.log((fn()))//fnnc
console.log(scope)//global   此处之所以值为global，是因为这时
//全局变量是无法获取到fn里的定义的scope,所以值才是global
 
2 .函数参数也是局部变量，只在函数体内有定义
 
function fn(p1,p2){
    console.log(p1)//99
    console.log(p2)//2
}
fn(99,2);
console.log(p1)//p1 is not defined
 
PS：在js里if语句不是一个作用域；
 因为根据局部变量无法被局部函数外所调用的原则，str应该为not defined，但是结果却是cx;
 
var num=1;
if(num==1){
    var str='cx'
}
console.log(str)//cx

变量
 
变量起作用的范围称为变量的作用域，不同的作用域内同名变量之间互不影响。变量分为：全局变量、局部变量。
 
全局变量：
 
在函数和类定义之外声明的变量，作用域为定义的模块，从定义位置开始直到模块结束。
全局变量降低了函数的通用性和可读性，应尽量避免全局变量的使用。
全局变量一般做常量使用。
函数内要改变全局变量的值，使用global声明一下
局部变量：
 
在函数体中（包含形式参数）声明的变量
局部变量的引用比全局变量快，优先考虑使用局部变量
如果局部变量和全局变量同名，则在函数内隐藏全局变量，只使用同名的局部变量。
全局变量的作用域测试：
 
a=2020      #全局变量
def one():
    global a   #如果在函数内改变全局变量的值，使用global关键字声明
    print(a)   #打印全局变量a的值
    a=20200528  #修改全局变量的值

one()
print(a)

#执行返回
>>>2020
   20200528
 
***在调用函数时，函数底层的变化。函数内部的变量将在栈中形成栈帧（也称为startframe），帧只包含函数体中局部变量（不包含全局变量），在调用函数后，帧消失，再次调用函数时，在形成栈帧帧。
 
输出局部变量和全局变量
 
a=100

def one(a,b,c):
    print(a,b,c)
    print(locals())     #打印输出局部变量
    print("---->"*20)
    print(globals())    #打印输出全局变量

one(11,22,33)
 
结果返回
 
 
有关全局和局部变量效率的测试

 
c语言中，变量按作用域角度分，分为局部变量和全局变量。
 

 
 
1、局部变量是在一个函数内部或一个代码块中定义的变量，只能在被函数和代码块范围内有效。如：
 
 
void test()
{
	int b = 20; // b是一个局部变量，在test函数内有效
}

int main()
{
	int a = 10; // a是一个局部变量，在main函数内有效
	test();

	{
		int c = 30; //c也是一个局部变量，在大括号内有效
	}
}

 注意：

 主函数main中定义的变量a也只能在主函数内有效，虽然主函数调用了test函数，但a并不在test函数内有效，主函数也不能使用test函数内定义的b变量。 
 

 
 
不同函数中可以使用相同的函数名，互不干扰，因为他们的作用域不同，所以不会发生混乱的情况。例如a、b、 c这3个变量在内存中分别占用不同的单元，不会发生混乱，其实是可以起同名的变量的，比如都可以叫做a。
 

 
 
形式参数也是局部变量。
 

 
 
在一个函数内部，用大括号括起来的一段代码块，叫做程序块。在程序块中定义的变量，也是只在本程序块中才有效的。离开本程序块，就无效，释放内存单元。
 

 
 
2、局部变量的修饰词 有 auto，static ，register。
 
2.1 auto修饰时 ，指该局部变量为存储在内存的动态存储区，函数中的形参和函数中定义的变量都属此类，在调用函数时系统会给他们分配存储空间，在调用结束后，就会销毁。
 

 
 
auto 修饰词可省略。
 

 
 
程序中的大多数变量都属于自动变量： 如上例当中的a、b、c都是auto类型的局部变量。
 

 
 
2.2 static 修饰时，指该局部变量为存储在内存静态存储区的静态局部变量，该变量并不随定义的函数的调用完毕而销毁，而是在本文件结束时才销毁。
 

 
 
 
int test(int a)
{
	static int c = 3;
	auto int b = 0;
	b = b + 1;
	c = c + 1;
	return (a + b + c);
}

int main()
{
	int a = 2, i;
	for (i = 0; i < 3; i++)
	{
		printf("%d\n", test(a));
	}
}

 第一次调用test时，b 、c初始值为0 、3，调用结束时，b、c为1、 4，而第二次调用时因为c为 static静态存储的局部变量，所以c的初始值为4，而b则清空为0 
 

 
 
static 修饰局部变量，会延长局部变量的生命周期，当程序结束时才会被销毁。但不会改变局部变量的作用域，也就是说上例中的main函数是不能直接访问test函数中的c的。
 
所有的test函数共享同一个c变量。
 

 
 
静态局部变量是在编译时赋值的，只赋值一次。如果在定义时没赋值，则自动赋值为0或null，而对于auto类型的局部变量来说，不赋初值就是一个不确定的值，很危险。
 
 

 
 
这种static修饰局部变量的使用场合有：
 

 
 
如果某个函数的调用频率特别高，用静态局部变量会节省很多内存。
 

 
 
这个函数的 内部的某个变量值是固定不变的，那么用静态局部变量就会很好用。因为所有test函数共用一个c。
 

 
 
2.3 register修饰的局部变量是寄存器局部变量。
 

 
 

 
 
3、全局变量是定义在函数之外的变量。
 

 
 
全局变量为所有函数所公用，所以称之为全局。
 

 
 
3.1 用extern修饰的全局变量为外部变量
 

 
 
 
int test(int x, int y)
{
	int z;
	z = x > y? x : y;
	return z;
}

int main()
{
	extern int a, b;
	printf("%d\n", test(a, b));
}

int a = 10, b = 2;

 extern外部变量是在函数外定义的，作用域为所有文件都可访问，可省写extern。 
 

 
 
3.2 static修饰的全局变量为内部变量。
 

 
 
static修饰的全局变量不能被其他文件所访问，只能限制于本文件中访问。成为静态外部变量。
 

 
 
注意：
 
static并不是意味着不加就不在内存的静态存储区存储，外部变量加不加static都是在静态存储区存储的，只是作用范围不同而已，都是在编译时分配内寸的。
 

 
 
例子：
 
static int a = 1;

void test()
{
	printf("%d\n", a);
}

int main()
{
	printf("%d\n", a);
	test();
}



 
 

 
 

 
 

 

原链接：点击打开链接

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 中寄存器的个数是有限的，因此使用寄存器变量的个数也是有限的。 

——————————————————————————————————————————


原链接：点击打开链接
静态变量，就是在定义的时候，有static 修饰的变量，形式为
static TYPE var_name = init_value;
而动态变量，形式为
TYPE var_name = init_value;
即没有static 修饰。其中的=init_value均可省略。
区分定义在函数外的全局变量，和函数内的局部变量，作用域，生命周期，及无显式初始化时的初始值，均有区别。
1 动态全局变量：
作用域为整个项目，即最终编译成可执行文件的所有文件中均可以使用动态全局变量。
生命周期为从程序运行到程序退出，即贯穿整个运行时间。
无显式初始化时默认初始化值为0。

2 静态全局变量：
作用域为当前文件，从定义/声明位置到文件结尾。
生命周期为从程序运行到程序退出，即贯穿整个运行时间。
无显式初始化时默认初始化值为0。

3 动态局部变量：
作用域为当前函数，从定义位置，到其所在的{}的结束位置。
生命周期为从函数调用到函数退出。
无显式初始化时默认初始化值为随机值。

4 静态局部变量：
作用域为当前函数，从定义位置，到其所在的{}的结束位置。
生命周期为从程序运行到程序退出，即贯穿整个运行时间，当下次函数调用时，静态局部变量不会被再次初始化，而是沿用上次函数退出时的值。
无显式初始化时默认初始化值为0。


#include<stdio.h>
int fun3(int x)
{
	static int a=3;
	a+=x;
	return(a);
}
main()
{	
	int k=2, m=1, n;
	n=fun3(k);
	n=fun3(m);
	printf("%d\n",n);            //6
}
#include<stdio.h>
int fun(int x[],int n)
{
	static int sum=0,i;
	for(i=0;i<n;i++) sum+=x[i];
	return sum;
}
main()
{
	int a[]={1,2,3,4,5},b[]={6,7,8,9,},s=0;
	s=fun(a,5)+fun(b,4);
	printf("%d\n",s);   //60
}


#include<stdio.h>
int a,b;
void fun()
{
	a=100;
	b=200;
}

main()
{
	int a=5,b=7;
	fun();
	printf("%d,%d\n",a,b);        //5,7
}


#include<stdio.h>
void fun(){
	static int a=0;
	a+=2;
	printf("%d",a);
}

main(){
	int cc;
	for(cc=1;cc<4;cc++) fun();    //246
	printf("\n");
}



以下叙述中正确的是___A___。
A、局部变量说明为static 存储类，其生存期将得到延长
B、全局变量说明为static 存储类，其作用域将被扩大
C、任何存储类的变量在未赋初值时，其值都是不确定的

D、形参可以使用的存储类说明符与局部变量完全相同