CC++中的静态全局变量,静态局部变量,全局变量,局部变量的区别
static全局变量与普通的全局变量有什么区别
(1)用于全局变量：外部静态变量，只能在本源文件中被引用，不能被其它源文件所引用。
(2)用于局部变量：局部静态变量，在函数返回后存储单元不释放；下一次调用该函数时，该变量为上次函数返回时的值。
(3)用于函数：内部函数，只能被本源文件中的函数所调用，不能被其它源文件调用。
Static全局变量与普通的全局变量有什么区别：1.static全局变量只初使化一次，防止在其他文件单元中被引用;2.static局部变量只被初始化一次，下一次依据上一次结果值；3.static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝const关键字在C语言中用于声明”只读变量”，其值不可修改，但具有确定的数据类型。
C 编译器总是为其分配相应的存储单元。
在C++中，const关键字用于声明常量，C++编译器视具体情况决定是为其分配存储单元还是仅将其作为编译期间的常量。
在C++中，还可以修饰类的成员函数，不改变类中的数据成员.被const 修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。
char * const p; //常量指针，p的值不可以修改char const * p；//指向常量的指针，指向的常量值不可以改const char *p； //和char const *pASSERT()是一个调试程序时经常使用的宏，在程序运行时它计算括号内的表达式，如果表达式为FALSE (0), 程序将报告错误，并终止执行。
如果表达式不为0，则继续执行后面的语句。
这个宏通常原来判断程序中是否出现了明显非法的数据，如果出现了就终止程序以免导致严重后果，同时也便于查找错误。
例如，变量n在程序中不应该为0，如果为0可能导致错误，你可以这样写程序：const作用：修饰变量、修饰函数参数、修饰函数返回值三个作用。
被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。
1）const变量有数据类型，而宏常量没有数据类型。
变量和函数与静态动态局部和全局
计算机C语言核心知识点-变量和函数变量可以在程序中三个地方进行说明: 函数内部、函数的参数定义中或所有的函数外部。
根据所定义位置的不同, 变量可分为局部变量、形式参数和全局变量。
从空间角度来看，变量可以分为全局变量和局部变量，而从时间角度来分的可以有静态存储变量和动态存储变量之分。
一.全局变量和局部变量C语言中广泛使用局部变量来进行相关的存储的运算。
在一个函数模块中定义的变量成为局部变量，我们一般在进入函数的地方进行局部变量的定义，局部变量在定义的时候需要被赋予初始值，否则会是系统被分配的随机值。
局部变量的作用范围在函数体内部，每次进行函数的调用的时候，则进行局部变量的定义和分配内存单元。
也就是说随着被调用函数体的结束，局部变量会自动消失，内存空间会释放。
所以我们可以再不同的函数模块中去定义相同的局部变量。
他们之间互相不会影响，在执行完某个函数的时候，会释放相应的存储单元，其他的函数单元也能进行重新定义和开辟存储空间。
我们如果要使用函数体内部生成的布局变量的话，一般是通过静态变量来实现。
局部变量也称为内部变量。
局部变量是在函数内作定义说明的。
其作用域仅限于函数内部，离开该函数后再使用这种变量是非法的。
局部变量从存储方式上可分为动态(auto)存储类型和静态(static)存储类型。
动态存储类型的局部变量都是动态的分配存储空间，数据存储在动态存储区（栈）中。
函数调用结束后自动释放，生存期是在声明该变量的函数执行过程。
静态存储类型的局部变量则是静态的分配存储空间，数据存储在静态存储区中。
在程序整个运行期间都不释放，生存期贯穿于程序运行的整个过程。
函数中的局部变量，如不专门声明为static存储类别，默认都是动态地分配存储空间的，我们在平时的声明变量的过程中auto都是默认省略的。
C语言中也会广泛使用全局变量来进行运算。
全局变量也称为外部变量，是在函数的外部定义的，它的作用域为从变量定义处开始，到本程序文件的末尾。
c中static的作用和用法
一、static的基本概念二、static的作用1. 控制变量的作用域2. 保持变量的持久性3. 保护变量不被其他文件访问三、static的用法1. 在函数内部使用static修饰局部变量2. 在全局变量前使用static修饰3. 在函数前使用static修饰函数四、static与全局变量、局部变量以及extern的区别与通联五、static在不同编程语言中的应用情况六、总结一、static的基本概念在C语言中，static是一个重要的关键字，它可以用来修饰变量和函数，具有一定的特殊作用。
二、static的作用1. 控制变量的作用域当static修饰局部变量时，该变量的作用域仅限于声明它的函数内部，超出该函数范围后，该变量就无法被访问。
这种特性在一定程度上增强了函数的安全性和封装性，避免了变量被误用或意外修改的风险。
2. 保持变量的持久性一般情况下，局部变量的生命周期仅限于其所在的函数执行期间，函数执行完毕后，这些局部变量所占用的内存空间就会被回收。
但是，如果将局部变量使用static修饰后，它的生命周期将会被延长至整个程序的执行期间，即使函数执行完毕，该变量所占用的内存空间也不会被回收。
这种特性有利于在多次调用同一个函数时，保持上一次调用的状态信息。
3. 保护变量不被其他文件访问当static修饰全局变量时，该全局变量的作用范围会被限制在声明它的文件内部，其他文件无法直接访问该全局变量。
这为数据的封装和保护提供了可能。
三、static的用法1. 在函数内部使用static修饰局部变量```void function() {static int a = 0;// other statements}```2. 在全局变量前使用static修饰```static int b = 0;// other statements```3. 在函数前使用static修饰函数```static void function() {// function statements}```四、static与全局变量和局部变量以及extern的区别与通联1. static全局变量和普通全局变量的区别在于作用域不同。
静态变量,全局变量,局部变量的区别
For personal use only in study and research; not for commercial use静态变量,全局变量,局部变量的区别1.C++变量根据定义的位置的不同的生命周期，具有不同的作用域，作用域可分为6种：全局作用域，局部作用域，语句作用域，类作用域，命名空间作用域和文件作用域。
从作用域看：1>全局变量具有全局作用域。
全局变量只需在一个源文件中定义，就可以作用于所有的源文件。
当然，其他不包含全局变量定义的源文件需要用extern关键字再次声明这个全局变量。
2>静态局部变量具有局部作用域，它只被初始化一次，自从第一次被初始化直到程序运行结束都一直存在，它和全局变量的区别在于全局变量对所有的函数都是可见的，而静态局部变量只对定义自己的函数体始终可见。
3>局部变量也只有局部作用域，它是自动对象（auto），它在程序运行期间不是一直存在，而是只在函数执行期间存在，函数的一次调用执行结束后，变量被撤销，其所占用的内存也被收回。
4>静态全局变量也具有全局作用域，它与全局变量的区别在于如果程序包含多个文件的话，它作用于定义它的文件里，不能作用到其它文件里，即被static 关键字修饰过的变量具有文件作用域。
这样即使两个不同的源文件都定义了相同名字的静态全局变量，它们也是不同的变量。
2.从分配内存空间看：1>全局变量，静态局部变量，静态全局变量都在静态存储区分配空间，而局部变量在栈里分配空间2>全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。
这两者在存储方式上并无不同。
这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。
而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。
由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。
c语言全局变量和局部变量区别
c语言全局变量和局部变量区别
全局变量和局部变量的区别有：1.有效范围不一样，2.内存空间不同，3.使用区间不同。
局部变量只在本函数范围有效，在此函数以外是不能使用这些变量；全局变量的有效范围是从定义变量的位置开始到本源文件结束。
局部变量是程序运行到该函数时给该变量分配内存空间，函数结束则释放该内存空间。
全局变量是程序运行时事先分配内存空间，当程序结束时释放内存。
全局变量：作用于整个程序文件；局部变量：作用于所属语句块或函数中。
全局变量的存有主要存有以下一些原因：采用全局变量可以挤占更多的内存（因为其生命期短），不过在计算机布局很高的今天，这个不必须算什么问题，除非采用的就是非常大对象的全局变量，能避免就一定必须防止。
采用全局变量程序运行时速度更慢一些（因为内存不须要再分配），同样也慢没法多少。
对于局部变量的名字空间污染，这个在不能采用太多变量时就是可以防止的。
当全局变量与局部变量下文的时候，起至促进作用的就是局部变量，全局变量被屏蔽掉。
还可以用extern在函数外对全局变量声明，并使全局变量的作用域从声明处至文件的完结。
全局变量的优先度高于局部变量。
总之，全局变量可以采用，但是全局变量采用时应特别注意的就是尽可能并使其名字不易认知，而且无法太短，防止名字空间的污染；防止采用非常大对象的全局变量。
在c语言等面向过程语言中，局部变量可以和全局变量下文，但是局部变量可以屏蔽全局变量。
在函数内提及这个变量时，可以使用同名的局部变量，而不能使用全局变量。
CC++中static的用法全局变量与局部变量
CC++中static的⽤法全局变量与局部变量1.什么是static? static 是C/C++中很常⽤的修饰符，它被⽤来控制变量的存储⽅式和可见性。
1.1static的引⼊ 我们知道在函数内部定义的变量，当程序执⾏到它的定义处时，编译器为它在栈上分配空间，函数在栈上分配的空间在此函数执⾏结束时会释放掉，这样就产⽣了⼀个问题: 如果想将函数中此变量的值保存⾄下⼀次调⽤时，如何实现？最容易想到的⽅法是定义为全局的变量，但定义⼀个全局变量有许多缺点，最明显的缺点是破坏了此变量的访问范围（使得在此函数中定义的变量，不只受此函数控制）。
static关键字则可以很好的解决这个问题。
另外，在C++中，需要⼀个数据对象为整个类⽽⾮某个对象服务,同时⼜⼒求不破坏类的封装性,即要求此成员隐藏在类的内部，对外不可见时，可将其定义为静态数据。
1.2静态数据的存储 全局（静态）存储区：分为DATA段和BSS段。
DATA段（全局初始化区）存放初始化的全局变量和静态变量；BSS段（全局未初始化区）存放未初始化的全局变量和静态变量。
程序运⾏结束时⾃动释放。
其中BBS段在程序执⾏之前会被系统⾃动清0，所以未初始化的全局变量和静态变量在程序执⾏之前已经为0。
存储在静态数据区的变量会在程序刚开始运⾏时就完成初始化，也是唯⼀的⼀次初始化。
在C++中static的内部实现机制：静态数据成员要在程序⼀开始运⾏时就必须存在。
因为函数在程序运⾏中被调⽤，所以静态数据成员不能在任何函数内分配空间和初始化。
这样，它的空间分配有三个可能的地⽅，⼀是作为类的外部接⼝的头⽂件，那⾥有类声明；⼆是类定义的内部实现，那⾥有类的成员函数定义；三是应⽤程序的main()函数前的全局数据声明和定义处。
静态数据成员要实际地分配空间，故不能在类的声明中定义（只能声明数据成员）。
类声明只声明⼀个类的“尺⼨和规格”，并不进⾏实际的内存分配，所以在类声明中写成定义是错误的。
C语言中的局部变量和全局变量
C语言中的局部变量和全局变量在C语言中，局部变量和全局变量是两种不同的变量类型，它们分别用于特定的程序设计需求。
本文将介绍局部变量和全局变量的定义、作用域以及在使用中的注意事项。
一、局部变量的定义和作用域局部变量是在函数内部声明的变量，它们只能在其所在的函数内部使用。
当函数被调用时，局部变量会在内存中被分配空间，当函数执行完毕后，局部变量所占用的内存会被释放。
局部变量的定义方式为在函数内部声明变量的语句前加上数据类型。
局部变量的作用域仅限于所在的函数内部。
这意味着其他函数无法直接访问同一名称的局部变量。
每个函数都有自己独立的局部变量，它们之间不会相互干扰。
局部变量的作用域可以有效地避免命名冲突，提高代码的可读性和可维护性。
二、全局变量的定义和作用域全局变量是在函数外部声明的变量，它们在整个程序中都可以被访问和使用。
全局变量的定义方式为在所有函数外部声明变量的语句前加上关键字"extern"和数据类型。
全局变量的作用域跨越整个程序，它们在程序开始执行时分配内存，在程序结束时释放内存。
全局变量可以在多个函数中共享数值，这对于需要在不同函数之间进行数据传递和共享的场景非常有用。
然而，全局变量的使用也需要谨慎。
过多的全局变量会增加程序的复杂性，不利于代码的维护和调试。
全局变量的值可以被任何函数修改，如果使用不当，可能会导致数据混乱和错误的结果。
三、局部变量和全局变量的差异1. 作用域：局部变量仅在函数内部可见，全局变量在整个程序中可见。
2. 生命周期：局部变量在函数执行期间存在，函数执行完毕后消失；全局变量在程序执行期间一直存在。
3. 访问限制：局部变量只能在定义它们的函数内部访问，其他函数无法直接访问；全局变量可以被所有函数访问。
4. 冲突风险：局部变量具有更小的命名冲突风险，全局变量存在更大的命名冲突可能性。
四、局部变量和全局变量的使用注意事项1. 命名冲突：在使用局部变量和全局变量时，应当避免重复使用相同的变量名，以防止命名冲突和代码混乱。
C语言中static和extern的区别
C语言中static和extern的区别C语言中static和extern的区别导语：由于变量的声明可以有多次，但定义只能有一次，这就不可避免地要使用extern，static关键字。
弄清楚这几个关键字之间的用法和区别，能节省很多调试项目的时间，尤其是对于一些难以定位的链接错误。
下面是C语言中static和extern的'区别，一起来学习下吧：static:一、在C中，static主要定义全局静态变量、定义局部静态变量、定义静态函数。
1、定义全局静态变量：在全局变量前面加上关键字static，该全局变量变成了全局静态变量。
全局静态变量有以下特点。
a.在全局区分配内存。
b.如果没有初始化，其默认值为0.c.该变量在本文件内从定义开始到文件结束可见。
2、定义局部静态变量：在局部变量前面加上关键字static，其特点如下：a.该变量在全局数据区分配内存。
b.它始终驻留在全局数据区，直到程序运行结束。
c. 其作用域为局部作用域，当定义它的函数或语句块结束时，其作用域随之结束。
3、定义静态函数：在函数返回类型前加上static关键字，函数即被定义为静态函数，其特点如下：a.静态函数只能在本源文件中使用b.在文件作用域中声明的inline函数默认为static类型二、在C++中新增了两种作用：定义静态数据成员或静态函数成员。
定义静态数据成员。
a.内存分配：静态数据成员在程序的全局数据去分配。
b.初始化和定义：静态数据成员定义时要分配空间，所以不能在类声明中定义。
静态数据成员因为程序以开始运行就必须存在，所以其初始化的最佳位置在类的内部，public、protected、private关键字对它的限定和普通数据成员一样，因为其空间在全局数据分配，属于所有本类的对象共享。
它不属于特定的类对象，在没产生类对象时，其作用域可见，即没有产生类的实例时，就可以操作它了。
静态成员函数。
静态成员函数与类相联系，不与类的对象相联系。
c语言局部变量和全局变量可以同名吗
c语⾔局部变量和全局变量可以同名吗
C语⾔中全局变量和局部变量的区别是他们的作⽤域不同，全局变量是整个C程序，局部变量是定义所在的⼤括号内，同⼀个作⽤域内不能定义两个同类型同名的变量，因为编译会报错。
由1个或者多个C⽂件组成的⼯程中，可以定义和全局变量同名同类的局部变量，但是不提倡这样使⽤，因为此时变量的值和变量被调⽤的位置有关系。
使⽤全局变量时，需要先⽤extern关键字声明，全局函数也是⽤相同的关键字。
顺便复习static关键字：
static主要定义全局静态变量、定义局部静态变量、定义静态函数。
特点
\⽤法
定义全局静态变量定义局部静态变量定义静态函数
内存全局数据区分配全局数据区分配⽆
作⽤域⽂件内定义开始到⽂件结束，其他⽂件不可⽤，
不可继承，其他⽂件可以定义重名变量
函数内定义开始到函数结束
⽂件内定义开
始到⽂件结束
可见域⽂件内定义开始到⽂件结束
函数内定义到⽂件结束，局部可⽤，但是全
局可见，局部函数返回其值可见
⽂件内定义开
始到⽂件结束。
局部变量与全局变量区别,栈、堆和静态存储区的区别
C++变量根据定义位置的不同，具有不同的作用域，作用域可分为6种：全局作用域，局部作用域，语句作用域，类作用域，命名作用域和文件作用域。
从作用域看：全局变量具有全局作用域。
全局变量只需在一个源文件中定义，就可以作用于所有的源文件。
当然，其他不包括全局变量定义的源文件需要用extern关键字再次声明这个全局变量。
静态局部变量具有局部作用域。
它只被初始化一次，自从第一次初始化直到程序与你新内阁结束都一直存在，他和全局变量的区别在于全局变量对所有的函数都是可见的，而静态局部变量只对定义自己的函数体始终可见。
局部变量也只有局部作用域，他是自动对象，他在程序运行期间不是一直存在，而是只在函数执行期间存在，函数的一次调用结束后，变量就被撤销，其所占用的内存也被收回。
静态全局变量也具有全局作用域，他与全局变量的区别在于如果程序包含多个文件的话，他作用于定义它的文件里，不能作用到其他文件里，即被static关键字修饰过的变量具有文件作用域。
这样即使两个不同的源文件都定义了相同的静态全局变量，他们也是不同的变量。
从分配内存空间看：全局变量、静态局部变量、静态全局变量都在静态存储区分配空间，而局部变量在栈分配空间。
全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。
这两者在存储方式上没有什么不同。
区别在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。
而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其他源文件中不能使用它。
由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其他源文件中引起错误。
1、静态变量会被放在程序的静态数据存储区里，这样可以在下一次调用的时候还可以保持原来的赋值。
这一点是他与堆栈变量和堆变量的区别2、变量用static告知编译器，自己仅仅在变量的作用域范围内可见。
局部变量,局部静态变量,全局变量,全局静态变量分别教学内容
局部变量,局部静态变量,全局变量,全局静态变量分别c++内存到底分几个区？一：1、栈区（stack）—由编译器自动分配释放，存放函数的参数值，局部变量的值等。
其操作方式类似于数据结构中的栈。
2、堆区（heap）—一般由程序员分配释放，若程序员不释放，程序结束时可能由os回收。
注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。
3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。
- 程序结束后有系统释放。
4、文字常量区—常量字符串就是放在这里的。
程序结束后由系统释放。
5、程序代码区—存放函数体的二进制代码。
二：1、栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。
里面的变量通常是局部变量、函数参数等。
2、堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。
如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
3、自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。
4、全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的c语言中，全局变量又分为初始化的和未初始化的，在c++里面没有这个区分了，他们共同占用同一块内存区。
5、常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改。
三：1、bss是英文block started by symbol的简称，通常是指用来存放程序中未初始化的全局变量的一块内存区域，在程序载入时由内核清0。
bss段属于静态内存分配。
它的初始值也是由用户自己定义的连接定位文件所确定，用户应该将它定义在可读写的ram区内，源程序中使用malloc分配的内存就是这一块，它不是根据data大小确定，主要由程序中同时分配内存最大值所确定，不过如果超出了范围，也就是分配失败，可以等空间释放之后再分配。
10.2 全局变量、局部变量、静态变量
24
{
cout << p << endl; p = strtok(NULL, " ,.-"); //后续调用，第一个参数必须是NULL } return 0; }
This a sample string OK
12
char * p = strtok (str," ,.-&#L) //只要p不为NULL，就说明找到了一个子串
void Func()
{ static int n = 4; //静态变量只初始化一次
cout << n << endl;
++ n;
} int main()
输出结果：
{
4
Func(); Func(); Func();
5
}
6
11
静态变量应用:strtok的实现
#include <iostream>
#include <cstring>
char * Strtok(char * p,char * sep) {
static char * start ; //本次查找子串的起点 if(p)
start = p; for(; *start && strchr(sep,*start); ++ start); //跳过分隔符号 if( * start == 0)
4
全局变量和局部变量
定义在函数内部的变量叫局部变量（函数的形参也是局部变量） 定义在所有函数的外面的变量叫全局变量 全局变量在所有函数中均可以使用，局部变量只能在定义它的函数内部使用
c语言局部变量静态局部变量全局变量与静态全局变量
c语⾔局部变量静态局部变量全局变量与静态全局变量基本概念：作⽤域：起作⽤的区域，也就是可以⼯作的范围。
代码块：所谓代码块，就是⽤{}括起来的⼀段代码。
数据段：数据段存的是数，像全局变量就是存在数据段的代码段：存的是程序代码，⼀般是只读的。
栈(stack)：先进后出。
C语⾔中局部变量就分配在栈中。
局部变量 普通的局部变量定义的时候直接定义或者在前⾯加上autovoid func1(void){int i = 1;i++;printf("i = %d.\n", i);}局部变量i的解析：在连续三次调⽤func1中，每次调⽤时，在进⼊函数func1后都会创造⼀个新的变量i，并且给它赋初值1，然后i++时加到2，然后printf输出时输出2.然后func1本次调⽤结束，结束时同时杀死本次创造的这个i。
这就是局部变量i的整个⽣命周期。
下次再调⽤该函数func1时，⼜会重新创造⼀个i，经历整个程序运算，最终在函数运⾏完退出时再次被杀死。
静态局部变量(static)静态局部变量定义时前⾯加static关键字。
总结：1、静态局部变量和普通局部变量不同。
静态局部变量也是定义在函数内部的，静态局部变量定义时前⾯要加static关键字来标识，静态局部变量所在的函数在多调⽤多次时，只有第⼀次才经历变量定义和初始化，以后多次在调⽤时不再定义和初始化，⽽是维持之前上⼀次调⽤时执⾏后这个变量的值。
本次接着来使⽤。
2、静态局部变量在第⼀次函数被调⽤时创造并初始化，但在函数退出时它不死亡，⽽是保持其值等待函数下⼀次被调⽤。
下次调⽤时不再重新创造和初始化该变量，⽽是直接⽤上⼀次留下的值为基础来进⾏操作。
3、静态局部变量的这种特性，和全局变量⾮常类似。
它们的相同点是都创造和初始化⼀次，以后调⽤时值保持上次的不变。
不同点在于作⽤域不同全局变量定义在函数外⾯的变量，就叫全局变量。
普通全局变量普通全局变量就是平时使⽤的，定义前不加任何修饰词。
static关键字（修饰函数、局部变量、全局变量）
static关键字（修饰函数、局部变量、全局变量）在C语⾔中，static的字⾯意思很容易把我们导⼊歧途，其实它的作⽤有三条。
（1）先来介绍它的第⼀条也是最重要的⼀条：隐藏。
当我们同时编译多个⽂件时，所有未加static前缀的全局变量和函数都具有全局可见性。
为理解这句话，我举例来说明。
我们要同时编译两个源⽂件，⼀个是a.c，另⼀个是main.c。
下⾯是a.c的内容char a = 'A'; // global variable void msg() { printf("Hello\n"); }下⾯是main.c的内容int main(void) { extern char a; // extern variable must be declared before use printf("%c ", a); (void)msg(); return 0; }程序的运⾏结果是：A Hello你可能会问：为什么在a.c中定义的全局变量a和函数msg能在main.c中使⽤？前⾯说过，所有未加static前缀的全局变量和函数都具有全局可见性，其它的源⽂件也能访问。
此例中，a是全局变量，msg是函数，并且都没有加static前缀，因此对于另外的源⽂件main.c是可见的。
如果加了static，就会对其它源⽂件隐藏。
例如在a和msg的定义前加上static，main.c就看不到它们了。
利⽤这⼀特性可以在不同的⽂件中定义同名函数和同名变量，⽽不必担⼼命名冲突。
Static可以⽤作函数和变量的前缀，对于函数来讲，static的作⽤仅限于隐藏，⽽对于变量，static还有下⾯两个作⽤。
（2）static的第⼆个作⽤是保持变量内容的持久。
存储在静态数据区的变量会在程序刚开始运⾏时就完成初始化，也是唯⼀的⼀次初始化。
共有两种变量存储在静态存储区：全局变量和static变量，只不过和全局变量⽐起来，static可以控制变量的可见范围，说到底static还是⽤来隐藏的。
局部变量、全局变量、堆、堆栈、静态和全局变量
局部变量、全局变量、堆、堆栈、静态和全局变量一般全局变量存放在数据区，局部变量存放在栈区，动态变量存放在堆区，函数代码放在代码区。
---------------------------------------------------------------栈区是普通的栈数据结构,遵循LIFO后进先出的规则,局部变量安排在那里是ASM时就规定的,这样可以在一个函数结束后平衡堆栈,操作简单,效率高堆(动态区)在这里应当叫堆栈(不要和数据结构中的堆搞混)是程序在编译时产生的一块用于产生动态内存分配使用的块,操作比较栈要麻烦许多,在分配时要判断最优的地址(防止产生无用的内存碎片(由于屡次的NEW和DELETE产生的夹在两块使用中内存中的空余小内存(不容易被分配))),分配和回收时的效率比栈低多了---------------------------------------------------------------栈是系统提供的功能，特点是快速高效，缺点是有限制，数据不灵活；而堆是函数库提供的功能，特点是灵活方便，数据适应面广泛，但是效率>有一定降低。
栈是系统数据结构，对于进程/线程是唯一的；堆是函数库内部数据结构，不一定唯一。
不同堆分配的内存无法互相操作。
栈空间分静态分配和动态分配两种。
静态分配是编译器完成的，比如自动变量(auto)的分配。
动态分配由malloca函数完成。
栈的动态分配无需释放(是自动的)，也就没有释放函数。
为可移植的程序起见，栈的动态分配操作是不被鼓励的！堆空间的分配总是动态的，虽然程序结束时所有的数据空间都会被释放回系统，但是精确的申请内存/ 释放内存匹>配是良好程序的基本要素。
堆是程序员管理的,栈是系统管理的.另外关于静态和全局的一些问题：静态变量的特点：1、一次存储：静态局部变量只被初始化一次，下一次初始化根据上一次的结果值，有点类似于c++中类的静态成员变量，即无论该类型生成多少个实例对象，所有的对象共用一个静态变量，到这里就是无论这个函数调用多少次，该静态变量只初始化一次，并没有因为超出其生存期而被销毁，只是外部不可见而已，用个例子说明之：void fun1( int v ){static int value = v;static int value = v;}int main( int arc, char*args[ ]){fun1( 50 );fun1( 100 );}执行的结果是：value : 50 value : 50说明在第二次调用fun1( )时的初始化value的采用的是上一次value的值，value在静态区的存储空间并没有因为fun1( )的结束而被释放，即体现了一次存储；2、作用域限定：静态修饰的作用域限定功能同时体现在函数与变量上；a)对于函数而言，任何用static修饰的函数，其作用域仅为当前源文件，而对外部来说这个函数是不可见的，即只有和其在同一源文件中的函数才能调用这个静态函数；反过来说，如果一个函数仅仅被同一源文件中的其他函数调用，那么这个函数应该声明为静态的，这样做的好处在于：可以一定程度上的解决不同源文件之间函数的命名冲突问题；b)对于变量而言，static修饰的全局变量，只在当前源文件中有效，对外部不可见，外部文件不能够引用；顾名思义，全局变量是指能够在全局引用的变量，相对于局部变量的概念，也叫外部变量；同静态变量一样，全局变量位于静态数据区，全局变量一处定义，多处引用，用关键字“extern”引用“外部”的变量。
局部变量和全局变量
1.1局部变量和全局变量C语言只允许在3个地方定义变量：函数内部、所有函数外部、复合语句中。
其中在函数内部和复合语句中声明的变量是局部变量。
在所有函数外部声明的变量叫全局变量。
局部变量：对于在函数的形参、内部声明的变量及结构变量等，编译器将在函数执行时为形参自动分配存储空间，在执行到变量和结构变量等的声明语句时为其自动分配存储空间，因此称其为自动变量（automatic variable），也称为局部变量，在函数执行完毕返回时，这些变量将被撤销，对应的内存空间将被释放。
自动变量的生存期只局限于它所在的代码块。
所谓代码块，是包含在花括号对中的一段代码，函数只是代码块的一种。
全局变量：在所有函数之外定义的变量叫做全局变量。
全局变量的有效范围从定义全局变量的位置开始到本源文件结束。
若在全局变量定义之前的函数想要引用该全局变量，则应在该函数中使用关键字extern作外部变量声明。
如果在同一个源文件中，外部变量和局部变量同名，则在局部变量的作用范围内，外部变量不起作用。
要引用外部变量可以通过域作用符::。
假如a.c中有个变量int x = 2;要想在b.c中用到a.c中的x可以在b.c中直接声明extern int x;就可以使用，如果想要在C++中调用c中的，如b.cpp中要用到a.c中的变量x就要采用如下形式：extern “C” int x;1.2动态存储和静态存储静态存储区中存放的变量在程序开始执行时分配存储单元，程序执行完毕时释放。
在程序执行过程中它们占据固定的存储单元，如全局变量就是存放在静态存储区。
动态存储区中存放的变量在函数调用开始时自动分配动态存储空间，函数结束时自动释放这些空间。
如局部变量就是存放在动态存储区。
C语言中存储类型主要有以下4中：auto（自动的）：局部变量默认的存储类型。
register（寄存器的）：变量存放在寄存器中而不是内存，现在已经不常用了static（静态的）：static变量的存储单元被分配在内存的静态存储区中。
static变量和static函数的各自的特点
static变量和static函数的各自的特点static变量大致分为三种用法一、用于局部变量中,成为静态局部变量. 静态局部变量有两个用法,记忆功能和全局生存期.二、用于全局变量,主要作用是限制此全局变量被其他的文件调用.三、用于类中的成员.表示这个成员是属于这个类但是不属于类中任意特定对象static 声明的变量在C语言中有两方面的特征：1、变量会被放在程序的全局存储区中，这样可以在下一次调用的时候还可以保持原来的赋值。
这一点是它与堆栈变量和堆变量的区别。
2、变量用static告知编译器，自己仅仅在变量的作用范围内可见。
这一点是它与全局变量的区别。
Tips:A.若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度；B.若全局变量仅由单个函数访问，则可以将这个变量改为该函数的静态局部变量，以降低模块间的耦合度；C.设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑重入问题；D.如果我们需要一个可重入的函数，那么，我们一定要避免函数中使用static 变量(这样的函数被称为：带“内部存储器”功能的的函数)E.函数中必须要使用static变量情况:比如当某函数的返回值为指针类型时，则必须是static的局部变量的地址作为返回值，若为auto类型，则返回为错指针。
函数前加static使得函数成为静态函数。
但此处“static”的含义不是指存储方式，而是指对函数的作用域仅局限于本文件(所以又称内部函数)。
使用内部函数的好处是：不同的人编写不同的函数时，不用担心自己定义的函数，是否会与其它文件中的函数同名。
扩展分析:术语static有着不寻常的历史.起初，在C中引入关键字static是为了表示退出一个块后仍然存在的局部变量。
随后，static在C中有了第二种含义：用来表示不能被其它文件访问的全局变量和函数。
为了避免引入新的关键字，所以仍使用static关键字来表示这第二种含义。
C++全局变量局部变量几个关键字的解释
C++全局变量局部变量⼏个关键字的解释
C++和其他程序设计语⾔不同，主函数main中定义的变量也是局部的，只有在主函数中才能使⽤。
在计算机中，内存被分为不同的区域。
按照变量在计算机内的储存位置来分，变量可以分为⾃动变量、静态变量、寄存器变量、外部变量。
下⾯逐个介绍。
⾃动变量auto
如果不专门声明为其他储存类型，都是⾃动变量。
因此 auto int a; 和int a; 是等价的。
## C++11中auto被⽤于⾃动推断了。
静态变量static
如果不希望该程序其他源⽂件中的函数使⽤某全局变量，可以设置为静态变量，保持结构良好。
如果是应⽤在局部变量，则该变量不再存放在函数对应的帧中，⽽是存放在全局变量区。
函数执⾏完毕依然存在，在下次函数调⽤时继续使⽤原空间中的值。
也就是说可以把该变量的信息带到下⼀次函数调⽤中。
另：1.未被初始化的静态变量都由系统初始化为0；2.如果程序中既有静态的局部变量也有全局变量，则系统先消亡静态的局部变量，再消亡全局变量。
寄存器变量register
只有局部⾃动变量才能定义为寄存器变量。
系统会把这些变量的值直接存储在CPU的寄存器中，⽤于代替⾃动变量。
现在的编译器可以识别出频繁使⽤的变量，并且会⾃动进⾏优化，不需要程序员去进⾏声明，⽽是编译器⾃⼰决定了。
外部变量extern
外部变量⼀定是全局变量，如果在定义点前或另⼀个源⽂件的函数也要使⽤，就可以设置为外部变量，使⽤时相当于告诉编译器此处使⽤了未见过的变量，将在别处定义。
以上。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
C|C++中的静态全局变量，静态局部变量，全局变量，局部变量的区别static有两种用法：面向过程程序设计中的static和面向对象程序设计中的static。
前者应用于普通变量和函数，不涉及类；后者主要说明static在类中的作用。
面向过程设计中的static全局变量、局部变量、静态全局变量、静态局部变量的区别C++变量根据定义的位置的不同的生命周期，具有不同的作用域，作用域可分为6种：全局作用域，局部作用域，语句作用域，类作用域，命名空间作用域和文件作用域。
从作用域看：全局变量具有全局作用域。
全局变量只需在一个源文件中定义，就可以作用于所有的源文件。
当然，其他不包含全局变量定义的源文件需要用extern 关键字再次声明这个全局变量。
静态局部变量具有局部作用域，它只被初始化一次，自从第一次被初始化直到程序运行结束都一直存在，它和全局变量的区别在于全局变量对所有的函数都是可见的，而静态局部变量只对定义自己的函数体始终可见。
局部变量也只有局部作用域，它是自动对象（auto），它在程序运行期间不是一直存在，而是只在函数执行期间存在，函数的一次调用执行结束后，变量被撤销，其所占用的内存也被收回。
静态全局变量也具有全局作用域，它与全局变量的区别在于如果程序包含多个文件的话，它作用于定义它的文件里，不能作用到其它文件里，即被static关键字修饰过的变量具有文件作用域。
这样即使两个不同的源文件都定义了相同名字的静态全局变量，它们也是不同的变量。
从分配内存空间看：全局变量，静态局部变量，静态全局变量都在静态存储区分配空间，而局部变量在栈里分配空间全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。
这两者在存储方式上并无不同。
这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。
而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。
由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。
1)、静态变量会被放在程序的静态数据存储区（数据段）(全局可见)中，这样可以在下一次调用的时候还可以保持原来的赋值。
这一点是它与堆栈变量和堆变量的区别。
2)、变量用static告知编译器，自己仅仅在变量的作用范围内可见。
这一点是它与全局变量的区别。
从以上分析可以看出，把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。
把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。
因此static 这个说明符在不同的地方所起的作用是不同的。
应予以注意。
Tips:A.若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度；B.若全局变量仅由单个函数访问，则可以将这个变量改为该函数的静态局部变量，以降低模块间的耦合度；C.设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑重入问题，因为他们都放在静态数据存储区，全局可见；D.如果我们需要一个可重入的函数，那么，我们一定要避免函数中使用static变量(这样的函数被称为：带“内部存储器”功能的的函数)E.函数中必须要使用static变量情况:比如当某函数的返回值为指针类型时，则必须是static的局部变量的地址作为返回值，若为auto 类型，则返回为错指针。
-----------------------------------------------------------------------------------------------------------static 全局变量:改变作用范围，不改变存储位置static 局部变量：改变存储位置，不改变作用范围静态函数：在函数的返回类型前加上static关键字,函数即被定义为静态函数。
静态函数与普通函数不同，它只能在声明它的文件当中可见，不能被其它文件使用。
如果在一个源文件中定义的函数，只能被本文件中的函数调用，而不能被同一程序其它文件中的函数调用，这种函数也称为内部函数。
定义一个内部函数，只需在函数类型前再加一个“static”关键字即可。
---------------------------------------------------------------------------------------------------------------二、面向对象的static关键字（类中的static关键字）静态数据成员有以下特点：对于非静态数据成员，每个类对象都有自己的拷贝。
而静态数据成员被当作是类的成员。
无论这个类的对象被定义了多少个，静态数据成员在程序中也只有一份拷贝，由该类型的所有对象共享访问。
也就是说，静态数据成员是该类的所有对象所共有的。
对该类的多个对象来说，静态数据成员只分配一次内存，供所有对象共用。
所以，静态数据成员的值对每个对象都是一样的，它的值可以更新；静态数据成员存储在全局数据区。
静态数据成员定义时要分配空间，所以不能在类声明中定义。
在Example 5中，语句int Myclass::Sum=0;是定义静态数据成员；静态数据成员和普通数据成员一样遵从public,protected,private访问规则；因为静态数据成员在全局数据区分配内存，属于本类的所有对象共享，所以，它不属于特定的类对象，在没有产生类对象时其作用域就可见，即在没有产生类的实例时，我们就可以操作它；静态数据成员初始化与一般数据成员初始化不同。
静态数据成员初始化的格式为：＜数据类型＞＜类名＞::＜静态数据成员名＞=＜值＞类的静态数据成员有两种访问形式：＜类对象名＞.＜静态数据成员名＞或＜类类型名＞::＜静态数据成员名＞如果静态数据成员的访问权限允许的话（即public的成员），可在程序中，按上述格式来引用静态数据成员；静态数据成员主要用在各个对象都有相同的某项属性的时候。
比如对于一个存款类，每个实例的利息都是相同的。
所以，应该把利息设为存款类的静态数据成员。
这有两个好处，第一，不管定义多少个存款类对象，利息数据成员都共享分配在全局数据区的内存，所以节省存储空间。
第二，一旦利息需要改变时，只要改变一次，则所有存款类对象的利息全改变过来了；同全局变量相比，使用静态数据成员有两个优势：静态数据成员没有进入程序的全局名字空间，因此不存在与程序中其它全局名字冲突的可能性；可以实现信息隐藏。
静态数据成员可以是private成员，而全局变量不能；2、静态成员函数与静态数据成员一样，我们也可以创建一个静态成员函数，它为类的全部服务而不是为某一个类的具体对象服务。
静态成员函数与静态数据成员一样，都是类的内部实现，属于类定义的一部分。
普通的成员函数一般都隐含了一个this指针，this指针指向类的对象本身，因为普通成员函数总是具体的属于某个类的具体对象的。
通常情况下，this 是缺省的。
如函数fn()实际上是this->fn()。
但是与普通函数相比，静态成员函数由于不是与任何的对象相联系，因此它不具有this指针。
从这个意义上讲，它无法访问属于类对象的非静态数据成员，也无法访问非静态成员函数，它只能调用其余的静态成员函数。
关于静态成员函数，可以总结为以下几点：出现在类体外的函数定义不能指定关键字static；静态成员之间可以相互访问，包括静态成员函数访问静态数据成员和访问静态成员函数；非静态成员函数可以任意地访问静态成员函数和静态数据成员；静态成员函数不能访问非静态成员函数和非静态数据成员；由于没有this指针的额外开销，因此静态成员函数与类的全局函数相比速度上会有少许的增长；调用静态成员函数，可以用成员访问操作符(.)和(->)为一个类的对象或指向类对象的指针调用静态成员函数，也可以直接使用如下格式：＜类名＞::＜静态成员函数名＞（＜参数表＞）调用类的静态成员函数。
================================================== =============================================static静态变量声明符。
在声明它的程序块，子程序块或函数内部有效，值保持，在整个程序期间分配存储器空间，编译器默认值0。
是C++中很常用的修饰符，它被用来控制变量的存储方式和可见性。
2、为什么要引入static?函数内部定义的变量，在程序执行到它的定义处时，编译器为它在栈上分配空间，大家知道，函数在栈上分配的空间在此函数执行结束时会释放掉，这样就产生了一个问题: 如果想将函数中此变量的值保存至下一次调用时，如何实现？最容易想到的方法是定义一个全局的变量，但定义为一个全局变量有许多缺点，最明显的缺点是破坏了此变量的访问范围（使得在此函数中定义的变量，不仅仅受此函数控制）。
3、什么时候用static?需要一个数据对象为整个类而非某个对象服务,同时又力求不破坏类的封装性,即要求此成员隐藏在类的内部，对外不可见。
4、static的内部机制：静态数据成员要在程序一开始运行时就必须存在。
因为函数在程序运行中被调用，所以静态数据成员不能在任何函数内分配空间和初始化。
这样，它的空间分配有三个可能的地方，一是作为类的外部接口的头文件，那里有类声明；二是类定义的内部实现，那里有类的成员函数定义；三是应用程序的main（）函数前的全局数据声明和定义处。
静态数据成员要实际地分配空间，故不能在类的声明中定义（只能声明数据成员）。
类声明只声明一个类的“尺寸和规格”，并不进行实际的内存分配，所以在类声明中写成定义是错误的。
它也不能在头文件中类声明的外部定义，因为那会造成在多个使用该类的源文件中，对其重复定义。
static被引入以告知编译器，将变量存储在程序的静态存储区而非栈上空间，静态数据成员按定义出现的先后顺序依次初始化，注意静态成员嵌套时，要保证所嵌套的成员已经初始化了。
消除时的顺序是初始化的反顺序。
5、static的优势：可以节省内存，因为它是所有对象所公有的，因此，对多个对象来说，静态数据成员只存储一处，供所有对象共用。
静态数据成员的值对每个对象都是一样，但它的值是可以更新的。
只要对静态数据成员的值更新一次，保证所有对象存取更新后的相同的值，这样可以提高时间效率。
6、引用静态数据成员时，采用如下格式：<类名>::<静态成员名>如果静态数据成员的访问权限允许的话(即public的成员)，可在程序中，按上述格式来引用静态数据成员。
7、注意事项：(1)类的静态成员函数是属于整个类而非类的对象，所以它没有this 指针，这就导致了它仅能访问类的静态数据和静态成员函数。