变量和函数与静态动态局部和全局
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++语言程序设计教程(第二版)
1.1习题1解答1.（1）机器语言是计算机直接理解执行的语言，由一系列（二进制）指令组成，其助记符构成了汇编语言；接近人的自然语言习惯的程序设计语言为高级语言。
（2）结构化程序设计方法主要内容有：自顶向下，逐步求精；面向对象方法将现实世界中的客观事物描述成具有属性和行为的对象，抽象出共同属性和行为，形成类。
（3）C++程序开发通常要经过5个阶段，包括：编辑，编译，连接，运行，调试。
首先是编辑阶段，任务是编辑源程序，C++源程序文件通常带有.c p p扩展名。
接着，使用编译器对源程序进行编译，将源程序翻译为机器语言代码（目标代码），过程分为词法分析、语法分析、代码生成3个步骤。
在此之前，预编译器会自动执行源程序中的预处理指令，完成将其他源程序文件包括到要编译的文件中，以及执行各种文字替换等。
连接器的功能就是将目标代码同缺失函数的代码连接起来，将这个“漏洞”补上，生成可执行文件。
程序运行时，可执行文件由操作系统装入内存，然后CPU从内存中取出程序执行。
若程序运行进程中出现了错误，还在需要对程序进行调试。
（4）对象与对象之间通过消息进行相互通信。
（5）类是具有相同属性和行为的一组对象的抽象；任何一个对象都是某个类的一个实例。
（6）多态性是指在一般类中定义的属性或行为，被特殊类继承之后，可以具有不同的数据类型或表现出不同的行为。
（7）面向对象的软件开发过程主要包括面向对象的方法分析、面向对象的设计、面向对象的编程、面向对象的测试和面向对象的维护。
（8）泛型程序设计是指在程序设计时，将数据类型参数化，编写具有通用性和可重用的程序。
（9）#include<iostream>是一条预处理指令（语句），在编译（或预处理）时由编译器（或预编译器）执行，其功能是将iostream文件包含（复制）到指令处。
（10）C++中使用cin作为标准输入流对象，通常代表键盘，与提取操作符>>连用；使用cout作为标准输出流对象，通常代表显示设备，与<<连用。
单片机C语言 必知的数据存储与程序编写知识 附单片机应用编程知识介绍
一、五大内存分区内存分成5个区，它们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。
1、栈区（StaCk）：FIFo就是那些由编译器在需要的时候分配，在不需要的时候自动清除的变量的存储区。
里面的变量通常是局部变量、函数参数等。
2、堆区（heap）：就是那些由new分配的内存块，它们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。
如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
3、自由存储区：就是那些由malloc等分配的内存块，它和堆是十分相似的，不过它是用free 来结束自己的生命。
4、全局/静态存储区：全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。
5、常量存储区：这是一块比较特殊的存储区，它们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改，而且方法很多）code/data/stack内存主要分为代码段，数据段和堆栈。
代码段放程序代码，属于只读内存。
数据段存放全局变量，静态变量，常量等，堆里存放自己malloc或new出来的变量，其他变量就存放在栈里，堆栈之间空间是有浮动的。
数据段的内存会到程序执行完才释放。
调用函数先找到函数的入口地址，然后计算给函数的形参和临时变量在栈里分配空间，拷贝实参的副本传给形参，然后进行压栈操作，函数执行完再进行弹栈操作。
字符常量一般放在数据段，而且相同的字符常量只会存一份。
二、C语言程序的存储区域1、由C语言代码（文本文件）形成可执行程序（二进制文件），需要经过编译-汇编-连接三个阶段。
编译过程把C语言文本文件生成汇编程序，汇编过程把汇编程序形成二进制机器代码，连接过程则将各个源文件生成的二进制机器代码文件组合成一个文件。
2、C语言编写的程序经过编译-连接后，将形成一个统一文件，它由几个部分组成。
局部变量和全局变量
{ int c;
c=a＞b?a:b;
//把a和b中的大者
存放在c中
return (c);
局部变量a的作用范围 全局变量b的作用范围
形参a,b的作用范围
运行结果： max=8
程序分析：在此例中，故意重复使用a和b3变量名，请 读者区别不同的a和b的含义和作用范围。程序第二行定义了 全局变量a和b，并使之初始化。第三行是main函数，在 main函数中（第六行）定义了一个局部变量a。局部变量a 的作用范围为第6-8行。在此范围内全局变量a 被局部变量a 屏蔽，相当于全局变量a在此范围内不存在（即它不起作 用），而全局变量b在此范围内有效。因此第六行max（a， b）的实参a应是局部变量a，所以max（a，b）相当于max （8,5）。它的值为8。
全局变量
在函数内定义的变量是局部变量，而在函数之外定义的变量为外部 变量，外部变量是全局变量（也称全程变量）。全局变量可以为本 文件中其他函数所共用。它的有效范围 为从定义变量的位置开始到 本源文件结束。 注意:在函数内定义的变量是局部变量，在函数外定义的变量是全局 变量。
分析下面的程序段： int p=1,q=5; float f1(int a) {
为了便于区别全局变量和局部变量，在C程序设计人员中有一个习惯 （但非规定），将全局变量名的第一个字母用大写表示。
例7.14 有一个一维数组，内放10个学生成绩，写一个函数，当主函数 调用此函数后，能求出平均分，最高分和最低分。
解题思路：调用一个函数可以得到函数的返回值，现在希望通过函数 调用能得到3个结果。可以利用全局变量来达到此目的。
(4) 在一个函数内部,可以在复合语句中定义变量,这些变量只 在本复合语句中有效,这种复合语句也称为“分程序”或“程 序块”。
C语言编程--变量的介绍
只有自动变量（或者形式参数）可以是寄存器变量，全局变量和局部变量不行。
函数中的寄存器变量在调用该函数时占用寄存器存放变量的值，当函数结束时释放寄存器，该变量消失。
犹豫计算机中寄存器数目有限，不能使用太多的寄存器变量。
寄存器变量只限于int型、char型和指针类型变量使用。如果寄存器使用饱和时，程序将寄存器变量自动转换为自动变量处理。
全局变量使用时要注意以下即个问题：①全局变量可以在多个函数中使用，当其中一个函数改变了全局变量的值，可能会影响其它函数的执行结果。②在一个函数内定义了一个与全局变量名相同的局部变量（或者是形参）时，局部变量有效，而全局变量在该函数内不起作用。
int m=1,n=2;
fl(int n) 形参n和全局变量m的作用范围，
C语言的变量定义时，根据百年来分配的存储空间的不同，可以分为自动变量、静态变量和寄存器变量。
①自动变量
自动变量的存储空间为内存中的动态数据区，该区域中的数据随程序需要动态地生成或释放。在函数体内或者复合遇见内定义的局部变量都属于自动变量。自动变量的类型修饰符auto放在变量的类型说明之前，auto int a；。但是auto一般是不写的。局部变量只要不专门说明是static存储类型，都确定为自动变量。
静态变量的特点是在程序的整个执行过程中始终存在，但是在它作用域之外不能使用。 静态变量的生存期就是整个程序的运行期。
静态变量的使用要特别注意:函数体内如果在定义静态变量的同时进行了初始化，则以后程序不再进行初始化操作。
在选择使用静态局部变量还是自动变量，可以从以下两点考虑：
变量：全局变量和局部变量
变量定义的位置可以是在函数内部，即局部变量，也可以在函数外部，即全局变量。
c语言的内存结构
c语言的内存结构C语言是一种高级编程语言，但实际上在计算机中运行时，C语言程序会被编译成可执行文件，然后在计算机内存中运行。
因此，了解C 语言的内存结构对于理解C程序的运行及性能优化至关重要。
C语言的内存结构主要可以分为以下几个部分：栈（Stack）、堆（Heap）、全局内存（Global Memory）和代码区（Code Segment）。
首先是栈（Stack），栈是一种自动分配和释放内存的数据结构。
它用于存储局部变量、函数参数和函数调用信息等。
栈的特点是后进先出（LIFO），也就是最后进入的数据最先被释放。
栈的大小在程序运行时是固定的，一般由编译器设置。
栈的操作速度较快，但内存空间有限。
其次是堆（Heap），堆是一种动态分配和释放内存的数据结构。
它用于存储动态分配的变量、数据结构和对象等。
堆的大小一般由操作系统管理，并且可以在运行时进行动态扩展。
堆的操作相对较慢，因为需要手动分配和释放内存，并且容易产生内存碎片。
全局内存（Global Memory）是用于存储全局变量和静态变量的区域。
全局变量在程序的生命周期内都存在，并且可以在多个函数之间共享。
静态变量作用于其所在的函数内，但是生命周期与全局变量相同。
全局内存由编译器进行分配和管理。
代码区（Code Segment）存储了程序的指令集合，它是只读的。
在程序运行时，代码区的指令会被一条一条地执行。
代码区的大小由编译器决定，并且在程序执行过程中不能修改。
此外，C语言还具有特殊的内存区域，如常量区和字符串常量区。
常量区用于存储常量数据，如字符串常量和全局常量等。
常量区的数据是只读的，且在程序的整个生命周期内存在。
字符串常量区是常量区的一个子区域，用于存储字符串常量。
在C语言中，内存分配和释放是程序员的责任。
通过使用malloc和free等函数，程序员可以在堆中动态地分配和释放内存，从而灵活地管理程序的内存使用。
不过，应当注意避免内存泄漏和野指针等问题，以免出现内存错误和性能问题。
字符串指针和字符数组,静态全局、静态局部、全局和局部变量区别,字符串常量和字符串变量,程序的内存分配
最近工作之余，发现了两个自己在C语言学习中的难点，一个是字符串指针和字符数组的区别，一个就是静态全局变量、静态局部变量、全局变量和局部变量的区别，在网上查了不少资料，收获良多，现在与大家分享，有错误的地方请大家指正！以下程序用VC++6.0调试先说说字符串指针和字符数组的区别1.相同点：/* 用字符数组实现字符串操作*/main( ){char str[]="Welcome to study C !";int i;printf("%s\n",str);for (i=0;i<=7;i++)printf("%c",str[i]); //用*(str+i)也行printf("\n");}/* 用字符指针实现字符串操作*/main(){char *str="Welcome to study C !";int i;printf("%s\n",str);for(i=0;i<=7;i++)printf("%c",*(str+i)); //用str[i]也行printf("\n");}2.不同点：a)赋值方式不同，字符数组只能对各个元素分别赋值，而字符指针只需赋给字符串的首地址就可以了。
如: char *str;str="Welcome to study C ！";以下对字符数组的赋值是错误的：char str[80];str[ ]="Welcome to study C ！";b)字符指针指向字符串，＂hello＂是一个字符串常量，与之相关联的内存空间位于内存的只读部分，如:char ch[] = "china\n";char *p;char *pp = "CHINA\n";p = ch;*(p+2) = 'h';//就是可以的*(pp+2) = 'h';//此处在编译时不会出错，在执行的时候会出错c) 函数参数列表中的以数组类型书写的形式参数,编译器把其解释为普通的指针类型，对于void func (char sa[100],int ia[20],char *p),则sa的类型为char*，而不是char[100]类型下面介绍一下字符串常量和字符串变量：1.字符串常量：a)定义：是一对双引号括起来的字符序列b)字符串包含的字符个数：不包括系统自动赋的’\0’，转义字符算1个c)所占的字节数：字符串所包含的字符个数加1d)长度：从第一个字符到第一个’\0’之间的字符个数，哪怕’\0’就在原字符串中e)无论字符串常量还是字符串变量，空字符串可以存在””，而空字符是错误的’’2.字符串变量：a)C语言本身没有设置一种类型来定义字符串变量，字符串的存储完全依赖于字符数组，但字符数组又不等于是字符串变量，例如：Char str[] = {‘a’,’b’,’c’,’\0’};是str[4]，是字符串Char str[] = {‘a’,’b’,’c’};是str[3],是字符数组Char str[7] = “string!”;可能破坏其他数据b)在scanf,printf,gets,puts中的str不用写成str[10],只能写成str下面介绍下静态全局变量，静态局部变量，全局变量，局部变量的区别1.从作用域看：全局变量具有全局作用域。
C++内存分配的五种方法
在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。
栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。
里面的变量通常是局部变量、函数参数等。
堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。
如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。
全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。
常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改，而且方法很多，在《const的思考》一文中，我给出了6种方法）明确区分堆与栈在bbs上，堆与栈的区分问题，似乎是一个永恒的话题，由此可见，初学者对此往往是混淆不清的，所以我决定拿他第一个开刀。
首先，我们举一个例子：void f() { int* p=new int[5]; }这条短短的一句话就包含了堆与栈，看到new，我们首先就应该想到，我们分配了一块堆内存，那么指针p呢？他分配的是一块栈内存，所以这句话的意思就是：在栈内存中存放了一个指向一块堆内存的指针p。
在程序会先确定在堆中分配内存的大小，然后调用o perator new分配内存，然后返回这块内存的首地址，放入栈中，他在VC6下的汇编代码如下：00401028 push 14h0040102A call operator new (00401060)0040102F add esp,400401032 mov dword ptr [ebp-8],eax00401035 mov eax,dword ptr [ebp-8]00401038 mov dword ptr [ebp-4],eax这里，我们为了简单并没有释放内存，那么该怎么去释放呢？是delete p么？澳，错了，应该是delete []p，这是为了告诉编译器：我删除的是一个数组，VC6就会根据相应的Cookie信息去进行释放内存的工作。
C++类中的静态成员变量和静态成员函数的作用
数据成员可以分静态变量、非静态变量两种.静态成员：静态类中的成员加入static修饰符,即是静态成员.可以直接使用类名+静态成员名访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态成员不能访问非静态的成员..因为静态成员存在于内存,所以非静态成员可以直接访问类中静态的成员.非成静态员：所有没有加Static的成员都是非静态成员,当类被实例化之后,可以通过实例化的类名进行访问..非静态成员的生存期决定于该类的生存期..而静态成员则不存在生存期的概念,因为静态成员始终驻留在内容中..一个类中也可以包含静态成员和非静态成员,类中也包括静态构造函数和非静态构造函数..分两个方面来总结，第一方面主要是相对于面向过程而言，即在这方面不涉及到类，第二方面相对于面向对象而言，主要说明static在类中的作用。
一、在面向过程设计中的static关键字1、静态全局变量定义：在全局变量前，加上关键字static 该变量就被定义成为了一个静态全局变量。
特点：A、该变量在全局数据区分配内存。
B、初始化：如果不显式初始化，那么将被隐式初始化为0(自动变量是随机的,除非显式地初始化)。
C、访变量只在本源文件可见，严格的讲应该为定义之处开始到本文件结束。
例（摘于C++程序设计教程---钱能主编P103）：//file1.cpp//Example 1#include <iostream.h>void fn();static int n; //定义静态全局变量void main(){n=20;cout < <n < <endl;fn();}void fn(){n++;cout < <n < <endl;}D、文件作用域下声明的const的常量默认为static存储类型。
静态变量都在全局数据区分配内存，包括后面将要提到的静态局部变量。
对于一个完整的程序，在内存中的分布情况如下图：代码区全局数据区堆区栈区一般程序的由new产生的动态数据存放在堆区，函数内部的自动变量存放在栈区。
c语言中变量的存储类别
一.C语言中，从变量的作用域角度来分，可以分为全局变量和局部变量。
二.变量值存在的时间角度来分，可以分为静态存储方式和动态存储方式。
所谓静态存储方式是指在程序运行期间有系统分配固定的存储空间的方式。
而动态存储方式则是在程序运行期间根据需要进行动态的分配存储空间的方式。
具体包含4种：自动的(auto),静态的(static),寄存器的(register),外部的(extern)。
1. 自动的(auto)在调用函数时系统会给他们分配存储空间，在函数调用结束时就自动释放这些存储空间，这类局部变量称为自动变量。
2. 静态的(static)为了满足局部变量的值在函数调用结束后不消失而且保留原值，既占用的存储单元不释放，就出现了静态的局部变量，用static来声明的局部变量。
局部变量的特点：(1)相对自动变量(即动态局部变量)，在程序的运行期间都占用静态存储区，直到程序结束才释放该存储区。
(2)静态局部变量只是在程序编译时赋初值，以后每次调用时不再重新赋初值，而只是保留上次函数调用结束时的值。
动态局部变量编译时不赋初值，直到程序调用时才给变量赋值，每次调用都要赋初值。
(3)在定义局部变量时不赋初值的话，则对静态局部变量来说，编译时会自动赋初值0或空字符。
而对动态局部变量，不赋初值则它的值是一个不确定的值，因为动态变量每次都要自动分配存储空间，存储空间的值是不固定的。
(4)静态局部变量在函数调用结束后不释放，但其他函数是不能调用的。
3．寄存器的(register)为了提高程序的执行效率，对一些运算频繁的变量定义为寄存器变量可以节省每次程序执行时的内存读取，大大节省了时间，提高了效率。
寄存器的一些特点：(1)寄存器变量的特点程序运行时分配寄存器存储空间，结束时释放。
这个特点限定了只能把局部自动变量和形式参数定义为寄存器变量。
(2)局部静态变量不能定义为寄存器变量。
4. 外部的(extern)外部变量是在函数的外部定义的全局变量，他的作用是从变量的定义初开始，到本程序文件的末尾。
全局变量与局部变量的区别
s=a+b; ……b 作用域 } …… s,a 作用域 } [例 5.11]main() { int i=2,j=3,k; k=i+j; { int k=8; if(i==3) printf("%d\n",k); } printf("%d\n%d\n",i,k); } main() { int i=2,j=3,k; k=i+j; { int k=8; if(i=3) printf("%d\n",k);
Байду номын сангаас
自动变量和寄 存器变量 属于 动态存储 方式 ， 外部变量和静态变 量属于静态存储方式。在介绍了变量的存储类型之 后， 可以知道对 一个变量的说明不仅应说明 其数 据类型， 还应说明 其存储类型。 因 此变量说明的 完整 形式应为： 存储类型说明符 数据类型说明 符 变
量名，变量名…； 例如： static int a,b; auto char c1,c2; static int a[5]={1,2,3,4,5}; extern int x,y; 说明 a,b 为静态类型变量 说明 c1,c2 为自动字符变量 说明 a 为静整型数组 说明 x,y 为外部整型变量。
总结与区别： 变量根 据定义的位置的不同 的生命周 期， 具有不同的 作用域， 作用域可分为 6 种： 全局作用域，局部作用域，语句作用域， 类作用域，命名空间作用域和文件作用域。 从作用域看： 全局变量具有全局作用域。全局变量只需 在一个源文件 中定义，就可 以作用于所有的源文件。当然，其 他不包含全局变量定义的源 文件需 要用 extern 关键字再次声 明这个全局变量。 静态局部变量具有局部作用域，它只 被初始化一次，自从第一次被初 始化直到程序运行结束都一直存在， 它和全局变量的区别在于 全局变 量对所有的函数都是可见的， 而静态局部变量只 对定义自己的函数体 始终可见。
1、局部变量能否和全局变量重名
1、局部变量能否和全局变量重名？答：能，局部会屏蔽全局。
要用全局变量，需要使用"::"局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。
对于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局部变量，而那个局部变量的作用域就在那个循环体内。
2、如何引用一个已经定义过的全局变量？答：extern可以用引用头文件的方式，也可以用extern关键字，如果用引用头文件方式来引用某个在头文件中声明的全局变理，假定你将那个变写错了，那么在编译期间会报错，如果你用extern方式引用时，假定你犯了同样的错误，那么在编译期间不会报错，而在连接期间报错。
3、全局变量可不可以定义在可被多个.C文件包含的头文件中？为什么？答：可以，在不同的C文件中以static形式来声明同名全局变量。
可以在不同的C文件中声明同名的全局变量，前提是其中只能有一个C 文件中对此变量赋初值，此时连接不会出错。
4、语句for( ；1 ；)有什么问题？它是什么意思？答：无限循环，和while(1)相同。
5、do……while和while……do有什么区别？答：前一个循环一遍再判断，后一个判断以后再循环。
6、请写出下列代码的输出内容＃i nclude<stdio.h>main(){int a,b,c,d;a=10;b=a++;c=++a;d=10*a++;printf("b，c，d：%d，%d，%d"，b，c，d）;return 0;}答：10，12，1201.static有什么用途？（请至少说明两种）1)在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。
2) 在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。
它是一个本地的全局变量。
3) 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。
全局变量和局部变量
C语言的变量一、全局变量和局部变量按照变量的有效作用范围可划分为局部变量和全局变量。
局部变量是在一个函数内部定义的变量，该变量只在定义它的那个函数范围以内有效，在此函数之外局部变量就失去意义了，因而也不能使用这些变量了。
不同的函数可以使用相同的局部变量名，由于他们的作用范围不同，不会相互干扰。
函数的形式参数也属于局部变量。
在一个函数内部的复合语句中也可以定义局部变量，该局部变量只在该复合语句中有效。
全局变量是在函数外部定义的变量，又称外部变量。
全局变量可以为多个函数共同使用，其有效的作用范围是从它定义的位置开始到整个程序文件结束为止。
如果全局变量定义在一个程序文件的开始处，则在整个程序文件范围内都可以使用它。
如果一个全局变量不是在程序文件的开始处定义的，但又希望在它的定义点之前的函数中引用该变量，这时应该在引用该变量的函数中用关键字extern将其说明为“外部变量”。
另外，如果在一个程序模块文件中引用另一个程序模块文件中定义的变量时，也必须用extern进行说明。
外部变量说明与外部变量定义是不同的。
外部变量定义只能有一次，定义的位置在所有函数之外，而同一个程序文件中的外部变量说明可以有多次，说明的位置在需要引用该变量的函数之内。
外部变量说明的作用只是声明该变量是一个已经在外部定义过了的变量而已。
如果在同一个程序文件中，全局变量与局部变量同名，则在局部变量的有效作用范围之内，全局变量是不起作用的，也就是说，局部变量的优先级比全局变量的高。
在编写C语言程序时，不是特别需要的地方就不要使用全局变量，二应当尽可能的使用局部变量。
这是因为局部变量只有在使用它时，才为其分配内存单元，二全局变量在整个程序的执行过程中都要占用内存单元。
另外，如果使用全局变量过多，在各个函数执行时都有可能改变全局变量的值，使人们难以清楚的判断出在各个程序执行点处全局变量的值，这样会降低程序的通用性和可读性。
还有一点需要说明，如果程序中的全局变量在定义时赋给了初值，按ANSI C标准规定，在程序进入主函数之前必须先对该全局变量进行初始化。
C语言 全局变量和局部变量的大小限制(堆栈区别)
#include <stdio.h>int main(){int a[1000000];//局部变量return 0;}编译运行后发现溢出错误。
#include <stdio.h>int a[1000000];//全局变量int main(){return 0;}编译运行后正常。
在解释原因前我们先看一下一个由C/C++编译的程序占用的内存分为几个部分：1、栈区(stack segment)：由编译器自动分配释放，存放函数的参数的值，局部变量的值等。
在Windows下，栈是向低地址扩展的数据结构，是一块连续的内存的区域。
这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M(也有的是1M，总之是一个编译时就确定的常数)，如果申请的空间超过栈的剩余空间时，将提示overflow。
因此，能从栈获得的空间较小。
2、堆区(heap segment)：一般由程序员分配释放，若程序员不释放，程序结束时可能由系统回收。
它与数据结构中的堆是两回事。
堆是向高地址扩展的数据结构，是不连续的内存区域。
这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。
堆的大小受限于计算机系统中有效的虚拟内存。
由此可见，堆获得的空间比较灵活，也比较大。
3、全局区(静态区)(data segment)：全局变量和静态变量的存储区域是在一起的，程序结束后由系统释放。
数据区的大小由系统限定，一般很大。
4、文字常量区：常量字符串就是放在这里的，程序结束后由系统释放。
5、程序代码区：存放函数体的二进制代码。
综上所述，局部变量空间是很小的，我们开一个a[1000000]就会导致栈溢出；而全局变量空间在Win 32bit 下可以达到4GB，因此不会溢出。
局部变量与全局变量
局部变量与全局变量1.局部变量以前定义变量的语句都是出现在某一函数中，这种变量称为局部变量。
主函数中定义的变量，用户自定义函数中的形参变量，自定义函数体内定义的变量都是局部变量。
局部变量的作用只限定在它的函数内，一个函数的局部变量不能出现在其它函数中。
局部变量在程序被编译时不会分配内存空间，只有当执行调用该函数的语句时，系统为局部变量分配内存，运行结束后，局部变量会释放它占有的内存单元，该内存单元再被操作系统回收，以备再用。
这种性质可以提高内存的利用率。
有时候，局部变量也可以定义在函数体内的复合语句中，但其作用只限于该复合语句，例如：int smd(int x,int y){int i,j;...{int k;...}...}其中变量k就是定义在复合语句中的局部变量，只在复合语句中起作用。
2.全局变量在所有函数之外定义的变量称作全局变量。
在一个c语言源程序文件中，全局变量可以定义在所有函数之前，也可以定义在所有函数之后，还可以定义在任意两个函数之间。
一般情况下，定义全局变量放在文件开头所有函数的前面。
如果全局变量在定义时没有被初始化，系统自动初始化为0（char型的为'/0'）。
再者注意，与局部变量相对应，全局变量在被编译时就分配了内存空间，一直保持到程序运行结束。
全局变量从定义之处到文件结束的所有函数都可以访问它，使用其当前值，或者改变其当前值，全局变量的值一旦改变，就保持这个新值，直到下一次改变。
全局变量的性质使得它能够在函数之间传递数据。
例如：在自定义函数与主函数之前，定义全局变量s l，其使用贯穿整个文件。
3.变量同名问题同一个程序内的全局变量不能同名，同一个人函数内的局部变量也不能同名。
但是，不同的函数的局部变量可以同名（两个函数不能同时被调用），同一个程序内的全局变量与它作用域内函数的局部变量也可以同名（起作用的是局部变量，全局变量被屏蔽掉）。
4.修饰符extern与static对全局变量和函数的修饰作用①．extern与static对全局变量的修饰如果c程序是由多个文件组成的，则其中一个文件中定义的全局变量的作用域从定义之处到本文件末。
变量的储存类别(Variable storage class)
c）函数调用时的现场保护和返回地址等
二、四种储存方法
1、auto变量
函数中的局部变量，如不专门声明为static储存类型，都是动态地分配储存空间的，数据储存在动态储存区中。
2、static声明局部变量
static声明的局部变量的值在函数调用结束后不消失而保留原值，即其占用的储存单元不释放，在下一次改函数调用时，改变量已有值，就是上一次函数调用结束时的值。
2, static local variable declaration
The static local variable declared value at the end of the function call does not disappear and leave, namely the storage unit the occupation does not release, in the next to a function call, change the value, is a function call at the end of the value.
a）在一个文件内声明外部变量。
如果外部变量不在文件的开头定义，其有效的作用范围只限于定义出到文件终了。如果在定义点之前的函数想引用该外部变量，则应该在引用之前用关键字extern对该变量做“外部变量声明”。表示该变量是一个已经定义的外部变量。有了此声明，就可以从“声明”处起，合法地使用该外部变量。
3, the register variable
In general, the value of a variable is stored in memory, when where a variable in a program value, the controller issued a directive to the variable has the value in memory to the ALU. After computing for operation, if the need to save the number, then the data is sent to the memory storage from operator. If the need for frequent storage, can put the value of the local variable is placed in the CPU register.
C语言中static变量详解
C语⾔中static变量详解Static翻译出来是“静态”“静⽌”的意思，在C语⾔中的意思其实和它的本意差不多，表⽰“静态”或者“全局”的意思，⽤来修饰变量和函数。
经static修饰过后的变量或者函数的作⽤域或者存储域会发⽣变化，⽽由static修饰的变量在初始值⽅⾯也会表现出static关键字的优势。
想知道经static修饰过后的变量或者函数的作⽤域或者存储域发⽣了什么变化吗，发⽣变化的原因是什么吗？请⼤家继续往下看！⼀、c程序的内存分布既然static是⽤来修饰变量和函数的，⽽变量和函数⼜是组成c程序必不可少的，C程序的内存分布图如下。
C程序由下⾯5部分组成： 1）正⽂段——CPU执⾏的机器指令部分；⼀个程序只有⼀个副本；只读，防⽌程序由于意外事故⽽修改⾃⾝指令； 2）初始化数据段（数据段）——在程序中所有赋了初值的全局变量，存放在这⾥。
3）⾮初始化数据段（bss段）——在程序中没有初始化的全局变量；内核将此段初始化为0。
4）栈——增长⽅向：⾃顶向下增长；⾃动变量以及每次函数调⽤时所需要保存的信息（返回地址；环境信息）。
5）堆——动态存储区。
是向⾼地址扩展的数据类型，是⾃下向上的扩展⽅式。
c程序内存分布图上⾯的C程序分布图很明显的告诉我们，变量是存储在栈区或者堆区或者bss段或者data段，变量的存储域为什么会有所不同呢？其实原因很简单，说⽩了就是与他们定义在程序的不同地⽅，有没有static关键字修饰有关啦，定义在不同的地⽅也说明了他们有着不同的作⽤域。
⼆、static修饰的变量1. 全局静态变量 在全局变量之前加上关键字static，全局变量就被定义成为⼀个全局静态变量。
1）内存中的位置：静态存储区（静态存储区在整个程序运⾏期间都存在） 2）初始化：未经初始化的全局静态变量会被程序⾃动初始化为0（⾃动对象的值是任意的，除⾮他被显⽰初始化） 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”引用“外部”的变量。
C51变量说明
变量是在程序运行过程中其值可以改变的量。
在C51中，在使用变量前必须对变量进行定义，指出变量的数据类型和存储模式，以便编译系统为它分配相应的存储单元。
变量的定义格式如下：[存储种类] 数据类型说明符[存储器类型] 变量名1[=初值]，变量名2[=初值]…；（1）格式说明1）存储种类是指变量在程序执行过程中的作用范围。
C51变量的存储种类有四种，分别是自动(auto)、外部(extern)、静态(static)和寄存器(register)。
定义变量时，如果省略存储种类，则该变量默认为自动(auto)变量。
用auto定义的变量作用范围仅在定义它的函数体或复合语句内部有效。
用extern定义的变量称为外部变量，其作用范围为整个程序。
用static定义的变量称为静态变量。
其作用范围仅在定义的函数体内有效，一直存在，再次进入该函数时，变量的值为上次结束函数时的值。
用register定义的变量称为寄存器变量，处理速度快，但数目少。
C51编译器编译时能自动识别程序中使用频率最高的变量，并自动将其作为寄存器变量，用户无需专门声明。
2）在定义变量时，必须通过数据类型说明符指明变量的数据类型，指明变量在存储器中占用的字节数。
可以是基本数据类型说明符，也可以是组合数据类型说明符，还可以是用typedef和#define定义的类型别名。
别名要按用户自定义标识符的原则命名。
例如：使用“#define uchar unsigned char”定义了“uchar”，则可以使用这个类型定义变量。
3）存储器类型是用于指明变量所处的单片机的存储器区域情况。
省略则默认为data类型，即片内前128字节的RAM；bdata为可位寻址内部数据存储器，定义的变量可以用sbit定义位变量访问其中的二进制位；idata 可以访问51的内部256字节的RAM；code定义的变量存储在程序存储器，只能读出不能写入，相当于常量。
4）变量名是C51区分不同变量，为不同变量取的名称，也就是用户自定义标识符，要遵循标识符的命名原则。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
计算机C语言核心知识点-变量和函数变量可以在程序中三个地方进行说明: 函数内部、函数的参数定义中或所有的函数外部。
根据所定义位置的不同, 变量可分为局部变量、形式参数和全局变量。
从空间角度来看，变量可以分为全局变量和局部变量，而从时间角度来分的可以有静态存储变量和动态存储变量之分。
一.全局变量和局部变量C语言中广泛使用局部变量来进行相关的存储的运算。
在一个函数模块中定义的变量成为局部变量，我们一般在进入函数的地方进行局部变量的定义，局部变量在定义的时候需要被赋予初始值，否则会是系统被分配的随机值。
局部变量的作用范围在函数体内部，每次进行函数的调用的时候，则进行局部变量的定义和分配内存单元。
也就是说随着被调用函数体的结束，局部变量会自动消失，内存空间会释放。
所以我们可以再不同的函数模块中去定义相同的局部变量。
他们之间互相不会影响，在执行完某个函数的时候，会释放相应的存储单元，其他的函数单元也能进行重新定义和开辟存储空间。
我们如果要使用函数体内部生成的布局变量的话，一般是通过静态变量来实现。
局部变量也称为内部变量。
局部变量是在函数内作定义说明的。
其作用域仅限于函数内部，离开该函数后再使用这种变量是非法的。
局部变量从存储方式上可分为动态(auto)存储类型和静态(static)存储类型。
动态存储类型的局部变量都是动态的分配存储空间，数据存储在动态存储区（栈）中。
函数调用结束后自动释放，生存期是在声明该变量的函数执行过程。
静态存储类型的局部变量则是静态的分配存储空间，数据存储在静态存储区中。
在程序整个运行期间都不释放，生存期贯穿于程序运行的整个过程。
函数中的局部变量，如不专门声明为static存储类别，默认都是动态地分配存储空间的，我们在平时的声明变量的过程中auto都是默认省略的。
C语言中也会广泛使用全局变量来进行运算。
全局变量也称为外部变量，是在函数的外部定义的，它的作用域为从变量定义处开始，到本程序文件的末尾。
全局变量全部存放在静态存储区，在程序开始执行时给全局变量分配存储区，程序行完毕就释放。
全局变量的特点如下：1. 在程序执行整个过程中它们占据固定的存储单元，而不动态地进行分配和释放；2. 如果外部变量不在文件的开头定义，其有效作用域只限于定义处到文件终。
也就是说文件中，在全局变量定义之前的地方需要使用全局变量，要使用extern这个关键词进行引用才能使用，通常我们把全局变量定义在文件的开头的地方，作用的范围是整个文件。
3. 全局变量定义了之后如果不赋给初始值的话，系统会自动给全局变量赋给初始值0。
如果是字符型，则会被默认赋值’\0’。
全局变量的分配存储空间在开始执行的时候，结束是在结束的时候，整个过程中一直占用存储空间，最后结束的时候，会进行资源的释放。
4. 全局变量定义在文件的开头的时候，作用范围为定义处到文件结束的地方。
现在的大型工程一般使用由多个文件构成，那么在其他文件中需要使用的时候，要用extern进行声明才能够使用。
5. 程序设计的规则是高内聚性和低耦合性，无疑全局变量使得程序之间的耦合性增强，所以要少用全局变量。
同时全局变量增加了系统的内存的开销。
6. 全局变量可以用引用头文件的方式，也可以用extern关键字，如果用引用头文件方式来引用某个在头文件中声明的全局变量，假定你将那个变量写错了，那么在编译期间会报错，如果你用extern方式引用时，假定你犯了同样的错误，那么在编译期间不会报错，而在连接期间报错。
7. 定义全局变量时，理想的位置是在文件的开头，当这些函数以及同一个程序中的其他源程序文件中的某些函数需要使用该全局变量时，我们在函数内部对该变量使用extern 加以说明，说明他是外部的。
这样程序设计比较的清晰。
在全部变量的作用范围内的函数直接引用全局变量。
在其他的源文件中，则需要进行全局变量的extern的声明。
8. 在程序中，局部变量可以和全局变量同名。
如果要使用全局变量，需要使用“：：”。
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。
对于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局部变量，而那个局部变量的作用域就在那个循环体内。
二．静态存储变量和动态存储变量这里分为static全局变量和普通的全局变量，static局部变量和普通局部变量，他们之间的区别如下：1. 全局变量的说明之前冠以static，就构成了静态的全局变量。
全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。
这两者在存储方式上并无不同。
这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。
而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。
由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。
2. 从以上分析可以看出，把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。
把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。
3. 程序的局部变量存在于（堆栈）中，全局变量存在于（静态区）中，动态申请数据存在于（堆）中。
补充：全局变量也称为外部变量，是在函数的外部定义的，它的作用域为从变量定义处开始，到本程序文件的末尾。
全局变量全部存放在静态存储区，在程序开始执行时给全局变量分配存储区，程序行完毕就释放。
在程序执行过程中它们占据固定的存储单元，而不动态地进行分配和释放；如果外部变量不在文件的开头定义，其有效作用域只限于定义处到文件终。
如果在定义点之前的函数想引用该外部变量，则应该在引用之前用关键字extern对该变量作“外部变量声明”。
表示该变量是一个已经定义的外部变量。
有了此声明，就可以从“声明”处起，合法地使用该外部变量。
其有效作用域就被拓展到从这个文件extern声明处到文件结束。
如果在全局变量声明的时候，前面加上关键字static，那么其他文件就不能再访问和使用该变量，其有效作用域只限于定义处到文件终。
一般全局变量存放在数据区，局部变量存放在栈区，动态变量存放在堆区，函数代码放在代码区。
三．C语言中的变量存储分类指定1.auto: auto称为自动变量,如果函数不做其他说明的话均为自动变量2.static:static称为静态变量,根据变量的类型可以分为静态局部变量和静态静态局部变量:它与局部变量的区别在于:在函数退出时,这个变量始终存在,但不能被其它函数使用,当再次进入该函数时,将保存上次的结果。
其它与局部变量一样。
静态全局变量：现在大系统一般有许多的文件组成，大型程序分成若干独立模块文件分别编译, 然后将所有模块的目标文件连接在一起, 从而提高编译速度, 同时也便于软件的管理和维护。
静态全程变量就是指只在定义它的源文件中可见而在其它源文件中不可见的变量。
它与全程变量的区别是: 全程变量可以再说明为外部变量(extern), 被其它源文件使用, 而静态全程变量却不能再被说明为外部的, 即只能被所在的源文件使用。
extern ：extern称为外部变量。
为了使变量除了在定义它的源文件中可以使用外, 还要被其它文件使用。
因此, 必须将全程变量通知每一个程序模块文件, 此时可用extern来说明。
四，寄存器变量Register：register称为寄存器变量。
它只能用于整型和字符型变量。
定义符register说明的变量被C编译器存储在CPU的寄存器中, 而不是象普通的变量那样存储在内存中, 这样可以提高运算速度。
但是C编译器只允许同时定义两个寄存器变量,一旦超过两个, 编译程序会自动地将超过限制数目的寄存器变量当作非寄存器变量来处理。
因此, 寄存器变量常用在同一变量名频繁出现的地方。
另外, 寄存器变量只适用于局部变量和函数的形式参数, 它属于auto型变量, 因此, 不能用作全程变量。
定义一个整型寄存器变量可写成:register int a;对于以上所介绍的变量类型和变量存储类型将会在以后的学习中, 通过例行程序中的定义、使用来逐渐加深理解。
程序的内存区域并不是所有的变量时时刻刻都是可知的。
一些变量在整个程序中都是可见的，它们称为全局变量。
一些变量只能在一个函数中可知，称为局部变量。
要了解变量的这些属性，应先弄清程序在内存中的分布区域，见图5-2。
图5-2 程序在内存中的区域一个程序将操作系统分配给其运行的内存块分为4个区域：(1)代码区，存放程序的代码，即程序中的各个函数代码块。
(2)全局数据区，存放程序的全局数据和静态数据。
(3)堆区，存放程序的动态数据。
(4)栈区，存放程序的局部数据，即各个函数中的数据。
五．静态函数与普通函数static函数与普通函数作用域不同，仅在本文件。
只在当前源文件中使用的函数应该说明为内部函数(static)，内部函数应该在当前源文件中说明和定义。
对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件。
静态全局变量与普通全局变量的区别在于：静态全局变量的作用域仅限于所在的源文件。
相关的总结：1.static全局变量与普通的全局变量有什么区别：static全局变量只初使化一次，防止在其他文件单元中被引用;2.static局部变量和普通局部变量有什么区别：static局部变量只被初始化一次，下一次依据上一次结果值；3.static函数与普通函数有什么区别：static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝.4.一般全局变量存放在数据区，局部变量存放在栈区，动态变量存放在堆区，函数代码放在代码区。
5.栈是系统提供的功能，特点是快速高效，缺点是有限制，数据不灵活；而栈是函数库提供的功能，特点是灵活方便，数据适应面广泛，但是效率>有一定降低。
栈是系统数据结构，对于进程/线程是唯一的；堆是函数库内部数据结构，不一定唯一。
不同堆分配的内存无法互相操作。
栈空间分静态分配和动态分配两种。
静态分配是编译器完成的，比如自动变量(auto)的分配。
动态分配由alloca 函数完成。
栈的动态分配无需释放(是自动的)，也就没有释放函数。
为可移植>的程序起见，栈的动态分配操作是不被鼓励的！堆空间的分配总是动态的，虽然程序结束时所有的数据空间都会被释放回系统，但是精确的申请内存/释放内存匹>配是良好程序的基本要素。
堆是程序员管理的,栈是系统管理的。
6.静态变量的特点：一次存储：静态局部变量只被初始化一次，下一次初始化根据上一次的结果值，有点类似于c++中类的静态成员变量，即无论该类型生成多少个实例对象，所有的对象共用一个静态变量，到这里就是无论这个函数调用多少次，该静态变量只初始化一次，并没有因为超出其生存期而被销毁，只是外部不可见而已，用个例子说明之：void fun1( int v ){static int value = v;static int value = v;a)对于函数而言，任何用static修饰的函数，其作用域仅为当前源文件，而对外部来说这个函数是不可见的，即只有和其在同一源文件中的函数才能调用这个静态函数；反过来说，如果一个函数仅仅被同一源文件中的其他函数调用，那么这个函数应该声明为静态的，这样做的好处在于：可以一定程度上的解决不同源文件之间函数的命名冲突问题；b)对于变量而言，static修饰的全局变量，只在当前源文件中有效，对外部不可见，外部文件不能够引用；顾名思义，全局变量是指能够在全局引用的变量，相对于局部变量的概念，也叫外部变量；同静态变量一样，全局变量位于静态数据区，全局变量一处定义，多处引用，用关键字“extern”引用“外部”的变量。