C语言中变量遵循“先定义后使用”的原则：
1、定义变量的格式：数据类型 变量名;
首先要强调的一点是：变量的定义是一条语句，每条语句都是以分号结尾的。故定义完变量，后面不要漏掉“；”分号。
在变量定义中，“数据类型”表示想要存储什么类型的数据就定义什么类型的变量。
如想要存储整数就定义成 int 型；想要存储小数就定义成 float 型或 double 型；想要存储字符就定义成 char 型等等。
“变量名”就是你想给这个变量起个什么名字，通常都是用字母、数字与下划线组合而成。比如：
“int i；double price；double goods_price2”等等。
就表示定义了一个整型变量 i、小数型变量price、goods_price2；
2、变量定义完成后，接下来就是使用变量，为变量赋值。
将一个值放到一个变量中，这个动作叫“赋值”。通俗点讲，“给变量赋值”意思就是将一个值传给一个变量。
赋值的格式是：
变量名 = 要赋的值;
它的意思是将=右边的数字赋给左边的变量。比如：
i = 3;
这就表示将 3 赋给了变量 i，此时 i 就等于 3 了。
3、变量的定义和赋值，可以分成两步写，也可以将它们合成一步，而且事实上，在实际编程中用得最多的也是合二为一的写法。
形式如下：
数据类型 变量名 = 要赋的值;
比如：int i = 3;
就表示定义了一个变量 i，并把 3 赋给这个变量。它与
int i;
i =3;
是等价的。
在定义变量时也可以一次性定义多个变量，比如：
int i, j;
这就表示定义了变量 i 和 j。这里需要强调的是，当同时定义多个变量时，变量之间是用逗号隔开的，千万别写成分号。这是很多新手最容易犯的错误，即将逗号和分号记混了。
同样也可以在定义多个变量的同时给它们赋值：
int i = 3, j = 4;
中间还是用逗号隔开，最后别忘记输入分号。
最后需要注意的是，在较老的 C89/C90 标准（也称 ANSI C 标准）中，变量只能在程序的开头定义，或者说变量定义的前面不能有其他非声明或非定义的语句。
扩展资料：
在主回答中，提到了变量定义时，变量名通常都是用字母、数字与下划线组合而成，但是实际上，变量名也不是随便组合的，变量定义需要遵循一定的规范，否则容易产生歧义，影响整体程序代码 的可读性。
所以在定义变量的时候，要注意以下命名规范：
（1）、变量名的开头必须是字母或下划线，不能是数字。实际编程中最常用的是以字母开头，而以下划线开头的变量名是系统专用的。命名应当直观且可以拼读，可望文知意，便于记忆和阅读。
标识符最好采用英文单词或其组合，不允许使用拼音。程序中的英文单词一般不要太复杂，用词应当准确。
（2）、变量名中的字母是区分大小写的。比如 a 和 A 是不同的变量名，num 和 Num 也是不同的变量名。当标识符由多个词组成时，每个词的第一个字母大写，其余全部小写。
比如： int CurrentVal；
这样的名字看起来比较清晰，远比一长串字符好得多。
（3）、变量名绝对不可以是C语言关键字，不能有空格。
（4）、变量名的长度应当符合“min-length && max-information”原则。
C 是一种简洁的语言, 命名也应该是简洁的。例如变量名MaxVal 就比MaxValueUntilOverflow 好用。标识符的长度一般不要过长，较长的单词可通过去掉“元音”形成缩写。
另外，英文词尽量不缩写，特别是非常用专业名词，如果有缩写，在同一系统中对同一单词必须使用相同的表示法，并且注明其意思。
温馨提示：答案为网友推荐，仅供参考
第1个回答 2008-07-08
浅谈C语言变量
王佰营 徐丽红
任何一种编程语言都离不开变量，特别是数据处理型程序，变量的使用非常频繁，没有变量参与程序甚至无法编制，即使编制运行后的意义也不大。变量之所以重要，是因为变量是编程语言中数据的符号标识和载体。
C语言是一种应用广泛的善于实现控制的语言，变量在C语言中的应用更是灵活多变。那么变量究竟是什么呢？变量是内存或寄存器中用一个标识符命名的存储单元，可以用来存储一个特定类型的数据，并且数据的值在程序运行过程中可以进行修改。可见，变量首先是一个标识符或者名称，就像一个客房的编号一样，有了这个编号我们在交流中就可方便言表，否则，我们只可意会，那多不方便。为了方便，我们在给变量命名时，最好能符合大多数人的习惯，基本可以望名知义，便于交流和维护；其次，变量是唯一确定的对应内存若干存储单元或者某个寄存器。这些是编译器来保证的，用户一般不用费心。
程序员一旦定义了变量，那么，变量就至少可为我们提供两个信息：一是变量的地址，即就是，操作系统为变量在内存中分配的若干内存的首地址；二是变量的值，也就是，变量在内存中所分配的那些内存单元中所存放的数据。
由于程序的多样需要，我们对变量也有各种各样的要求，比如：变量的生命期，变量的初始状态，变量的有效区域，变量的开辟地和变量的开辟区域的大小等等；为了满足这些要求，C语言的发明者就设置了以下变量：
1、 不同数据类型的变量；如：char cHar, int iTimes, flaot faverage;
2、 全局变量或者叫全程变量；
3、 局部变量；
4、 静态变量： 静态全局变量和静态局部变量；关键词：static
5、 寄存器变量；关键词：register;
6、 外部变量： 关键词：extern;
C语言中，变量在内存中开辟地的大小由数据类型决定的，由于PC机中规定一个地址单元存一个字节，不同的数据类型的变量，为其分配的地址单元数是不一样的。C语言中除几种基本的数据类型外用户还可以自己定义所需要的数据类型：
1、 bool型 sizeof(bool): 1
2、 char型: sizeof(char): 1
3、 short型: sizeof(short): 2
4、 int型: sizeof(int): 4
5、 long型: sizeof(long): 4
6、 float型: sizeof(float): 4
7、 double型: sizeof(double): 8
8、 自定义型：如：
typedef struct tagMyData
{
char cHar;
int iTimes;
float faverage;
}MyDatap;
sizeof(MyDatap): 12
char szBuf[]="HELLO C&C++!";
sizeof(szBuf): 13
局部变量和全局变量是相对而言的；如下：局部变量 int itmp;
int Get_Max( const int& x, const int& y, const int& z )
{
int itmp;
if(x > y) itmp = x;
else itmp = y;
if( itmp > z ) return itmp;
else return z;
}
在函数内部说明的变量为局部变量，只有在函数执行时，局部变量才存在，当函数执行完退出后，局部变量随之消失。也就是，当函数执行完退出后，原先在函数内定义的变量现在不能用，这通常由编译器保证，它会阻止编译通过。也就是说，原来为那个局部变量分配的内存，现在已经不属于它，它再无权访问了。如要再使用这些内存单元就必须从新定义变量来申请，只有分配给的变量才可访问它。否则，就会出错，如数组越界访问。
与局部变量不同，全局变量在整个程序都是可见的，可在整个程序运行过程中，对于任何一个程序都是可用的。全局变量的说明的位置在所有函数之外，但可被任何一个函数使用，读取或者写入。如下：全局变量 int iCount, bool bForward;
int iCount; //全局变量；
bool bForward; //全局变量；
void add( void );
void dec( void );
void man(void )
{
while( iCount < 1000 && iCount > -1000)
{
add( );
dec( );
printf("COUNT:%d;\n", iCount)
}
}
void add( void )
{
if( bForward ) iCount++;
}
void dec( void )
{
if(!bForward ) iCount--;
}
可见，全局变量非常方便不同函数间数据共享，同样，任何函数在在使用数据时，都不敢保证数据是否已被修改。如果程序员无法保证这个，就尽量避免使用全局变量。
静态变量是分配在存储器中C程序所占据的数据段内， C程序运行的整个过程中一直保留，不会被别的变量占用。静态变量可以定义成全局变量或局部变量，当定义为全局变量时，在它定义的程序的整个运行期间均存在并且保持原来的存储单元位置不会改变。那么既然有了全局变量为什么还要定义全局静态变量呢？看下边的示例：
模块1：
int a;
static int b;
void fun1( void )
{
……
fun2( );
……
}
模块2：
extern int a;
satic int b;
void fun2( void )
{
……
fun1( );
……
}
分别编译，然后链接两个模块。。。。。。
模块1和模块2中，变量a为同一个变量；而变量b就不是同一个变量！虽然它们的的数据类型和名称均相同；就是因为有static；原因是，如果在全局变量说明前加上静态变量说明符static,它就会通知编译器该全局变量只在被定义的这个文件或模块中可见的。就是说，该静态全局变量在其他文件中是不可见的，在其他文件中的程序是不允许访问的。这在一定程度上减少了全局变量的副作用的影响。
同静态全局变量定义一样，当在局部变量名前加静态变量说明符static,该变量就定义为静态局部变量。编译器为该变量建立永久存储单元。永久是指C程序运行的整个过程中一直保留，不会被别的变量占用。静态局部变量和静态全局变量的根本区别在作用区域上，静态局部变量只在它被说明的函数或复合语句中有效，并且在两次函数调用期间仍然保存其值不变，即就是有记忆功能；它们的生命期是相同的，和C程序整个运行期同在。如下例：
#include "stdafx.h"
void counts(void);
void countd(void)；
int main(int argc, char* argv[])
{
int i = 0;
while( i++<10)
{
counts( ); //使用静态局部变量
}
i = 0;
while( i++<10)
{
countd( ); //使用局部变量
}
return 0;
}
void counts(void) //使用静态局部变量
{
static int isc ; //未赋初值；
isc++;
printf("dsc = %d;\n", dsc);
}
void countd(void) //使用局部变量
{
int idc = 0;
idd++;
printf("idc=%d;\n",idc);
}
执行结果为：
isc = 1; //使用静态局部变量
isc = 2;
isc = 3;
isc = 4;
isc = 5;
isc = 6;
isc = 7;
isc = 8;
isc = 9;
isc = 10;
idc = 1; //使用局部变量
idc = 1;
idc = 1;
idc = 1;
idc = 1;
idc = 1;
idc = 1;
idc = 1;
idc = 1;
idc = 1;
通过以上程序你也看得出：
1、 局部变量和静态局部变量的区别：记忆功能；
2、 静态局部变量只初始化一次，并且默认初始化为0；
静态变量在定义时若未被赋值，则编译程序将其初始化为0；
寄存器变量不像其他变量那样在内存中存放数据，而是在CPU的寄存器中暂存数据，使用寄存器变量比使用内存变量的操作速度快得多。只有整型和字符型变量可定义为寄存器变量。定义方式如下：
register int iTemp;
由于CPU中寄存器有限，尽量减少使用数量和和占用时间，用完马上释放；不能定义为全局变量，也不能定义在结构或者类中。
为了大型程序的管理，将一个大型的程序分成若干个独立的模块和文件分别编译，然后统一链接在一起。为了解决全局变量和函数的共用问题，就引入了extern关键字。这样只需在一个文件中定义全局变量和函数，在另一个文件中要用到这些变量和函数时，只需将那个文件中的变量和函数说明表复制过来，在前面加上extern，告诉编译器，这些变量和函数已经在别的文件中定义说明，在此不必再定义说明了。
王佰营 徐丽红
任何一种编程语言都离不开变量，特别是数据处理型程序，变量的使用非常频繁，没有变量参与程序甚至无法编制，即使编制运行后的意义也不大。变量之所以重要，是因为变量是编程语言中数据的符号标识和载体。
C语言是一种应用广泛的善于实现控制的语言，变量在C语言中的应用更是灵活多变。那么变量究竟是什么呢？变量是内存或寄存器中用一个标识符命名的存储单元，可以用来存储一个特定类型的数据，并且数据的值在程序运行过程中可以进行修改。可见，变量首先是一个标识符或者名称，就像一个客房的编号一样，有了这个编号我们在交流中就可方便言表，否则，我们只可意会，那多不方便。为了方便，我们在给变量命名时，最好能符合大多数人的习惯，基本可以望名知义，便于交流和维护；其次，变量是唯一确定的对应内存若干存储单元或者某个寄存器。这些是编译器来保证的，用户一般不用费心。
程序员一旦定义了变量，那么，变量就至少可为我们提供两个信息：一是变量的地址，即就是，操作系统为变量在内存中分配的若干内存的首地址；二是变量的值，也就是，变量在内存中所分配的那些内存单元中所存放的数据。
由于程序的多样需要，我们对变量也有各种各样的要求，比如：变量的生命期，变量的初始状态，变量的有效区域，变量的开辟地和变量的开辟区域的大小等等；为了满足这些要求，C语言的发明者就设置了以下变量：
1、 不同数据类型的变量；如：char cHar, int iTimes, flaot faverage;
2、 全局变量或者叫全程变量；
3、 局部变量；
4、 静态变量： 静态全局变量和静态局部变量；关键词：static
5、 寄存器变量；关键词：register;
6、 外部变量： 关键词：extern;
C语言中，变量在内存中开辟地的大小由数据类型决定的，由于PC机中规定一个地址单元存一个字节，不同的数据类型的变量，为其分配的地址单元数是不一样的。C语言中除几种基本的数据类型外用户还可以自己定义所需要的数据类型：
1、 bool型 sizeof(bool): 1
2、 char型: sizeof(char): 1
3、 short型: sizeof(short): 2
4、 int型: sizeof(int): 4
5、 long型: sizeof(long): 4
6、 float型: sizeof(float): 4
7、 double型: sizeof(double): 8
8、 自定义型：如：
typedef struct tagMyData
{
char cHar;
int iTimes;
float faverage;
}MyDatap;
sizeof(MyDatap): 12
char szBuf[]="HELLO C&C++!";
sizeof(szBuf): 13
局部变量和全局变量是相对而言的；如下：局部变量 int itmp;
int Get_Max( const int& x, const int& y, const int& z )
{
int itmp;
if(x > y) itmp = x;
else itmp = y;
if( itmp > z ) return itmp;
else return z;
}
在函数内部说明的变量为局部变量，只有在函数执行时，局部变量才存在，当函数执行完退出后，局部变量随之消失。也就是，当函数执行完退出后，原先在函数内定义的变量现在不能用，这通常由编译器保证，它会阻止编译通过。也就是说，原来为那个局部变量分配的内存，现在已经不属于它，它再无权访问了。如要再使用这些内存单元就必须从新定义变量来申请，只有分配给的变量才可访问它。否则，就会出错，如数组越界访问。
与局部变量不同，全局变量在整个程序都是可见的，可在整个程序运行过程中，对于任何一个程序都是可用的。全局变量的说明的位置在所有函数之外，但可被任何一个函数使用，读取或者写入。如下：全局变量 int iCount, bool bForward;
int iCount; //全局变量；
bool bForward; //全局变量；
void add( void );
void dec( void );
void man(void )
{
while( iCount < 1000 && iCount > -1000)
{
add( );
dec( );
printf("COUNT:%d;\n", iCount)
}
}
void add( void )
{
if( bForward ) iCount++;
}
void dec( void )
{
if(!bForward ) iCount--;
}
可见，全局变量非常方便不同函数间数据共享，同样，任何函数在在使用数据时，都不敢保证数据是否已被修改。如果程序员无法保证这个，就尽量避免使用全局变量。
静态变量是分配在存储器中C程序所占据的数据段内， C程序运行的整个过程中一直保留，不会被别的变量占用。静态变量可以定义成全局变量或局部变量，当定义为全局变量时，在它定义的程序的整个运行期间均存在并且保持原来的存储单元位置不会改变。那么既然有了全局变量为什么还要定义全局静态变量呢？看下边的示例：
模块1：
int a;
static int b;
void fun1( void )
{
……
fun2( );
……
}
模块2：
extern int a;
satic int b;
void fun2( void )
{
……
fun1( );
……
}
分别编译，然后链接两个模块。。。。。。
模块1和模块2中，变量a为同一个变量；而变量b就不是同一个变量！虽然它们的的数据类型和名称均相同；就是因为有static；原因是，如果在全局变量说明前加上静态变量说明符static,它就会通知编译器该全局变量只在被定义的这个文件或模块中可见的。就是说，该静态全局变量在其他文件中是不可见的，在其他文件中的程序是不允许访问的。这在一定程度上减少了全局变量的副作用的影响。
同静态全局变量定义一样，当在局部变量名前加静态变量说明符static,该变量就定义为静态局部变量。编译器为该变量建立永久存储单元。永久是指C程序运行的整个过程中一直保留，不会被别的变量占用。静态局部变量和静态全局变量的根本区别在作用区域上，静态局部变量只在它被说明的函数或复合语句中有效，并且在两次函数调用期间仍然保存其值不变，即就是有记忆功能；它们的生命期是相同的，和C程序整个运行期同在。如下例：
#include "stdafx.h"
void counts(void);
void countd(void)；
int main(int argc, char* argv[])
{
int i = 0;
while( i++<10)
{
counts( ); //使用静态局部变量
}
i = 0;
while( i++<10)
{
countd( ); //使用局部变量
}
return 0;
}
void counts(void) //使用静态局部变量
{
static int isc ; //未赋初值；
isc++;
printf("dsc = %d;\n", dsc);
}
void countd(void) //使用局部变量
{
int idc = 0;
idd++;
printf("idc=%d;\n",idc);
}
执行结果为：
isc = 1; //使用静态局部变量
isc = 2;
isc = 3;
isc = 4;
isc = 5;
isc = 6;
isc = 7;
isc = 8;
isc = 9;
isc = 10;
idc = 1; //使用局部变量
idc = 1;
idc = 1;
idc = 1;
idc = 1;
idc = 1;
idc = 1;
idc = 1;
idc = 1;
idc = 1;
通过以上程序你也看得出：
1、 局部变量和静态局部变量的区别：记忆功能；
2、 静态局部变量只初始化一次，并且默认初始化为0；
静态变量在定义时若未被赋值，则编译程序将其初始化为0；
寄存器变量不像其他变量那样在内存中存放数据，而是在CPU的寄存器中暂存数据，使用寄存器变量比使用内存变量的操作速度快得多。只有整型和字符型变量可定义为寄存器变量。定义方式如下：
register int iTemp;
由于CPU中寄存器有限，尽量减少使用数量和和占用时间，用完马上释放；不能定义为全局变量，也不能定义在结构或者类中。
为了大型程序的管理，将一个大型的程序分成若干个独立的模块和文件分别编译，然后统一链接在一起。为了解决全局变量和函数的共用问题，就引入了extern关键字。这样只需在一个文件中定义全局变量和函数，在另一个文件中要用到这些变量和函数时，只需将那个文件中的变量和函数说明表复制过来，在前面加上extern，告诉编译器，这些变量和函数已经在别的文件中定义说明，在此不必再定义说明了。
参考资料：http://wbymcs51.blog.bokee.net/bloggermodule/blog_viewblog.do?id=758997
本回答被提问者采纳第2个回答 2019-07-14
浅谈C语言变量
王佰营
徐丽红
任何一种编程语言都离不开变量，特别是数据处理型程序，变量的使用非常频繁，没有变量参与程序甚至无法编制，即使编制运行后的意义也不大。变量之所以重要，是因为变量是编程语言中数据的符号标识和载体。
C语言是一种应用广泛的善于实现控制的语言，变量在C语言中的应用更是灵活多变。那么变量究竟是什么呢？变量是内存或寄存器中用一个标识符命名的存储单元，可以用来存储一个特定类型的数据，并且数据的值在程序运行过程中可以进行修改。可见，变量首先是一个标识符或者名称，就像一个客房的编号一样，有了这个编号我们在交流中就可方便言表，否则，我们只可意会，那多不方便。为了方便，我们在给变量命名时，最好能符合大多数人的习惯，基本可以望名知义，便于交流和维护；其次，变量是唯一确定的对应内存若干存储单元或者某个寄存器。这些是编译器来保证的，用户一般不用费心。
程序员一旦定义了变量，那么，变量就至少可为我们提供两个信息：一是变量的地址，即就是，操作系统为变量在内存中分配的若干内存的首地址；二是变量的值，也就是，变量在内存中所分配的那些内存单元中所存放的数据。
由于程序的多样需要，我们对变量也有各种各样的要求，比如：变量的生命期，变量的初始状态，变量的有效区域，变量的开辟地和变量的开辟区域的大小等等；为了满足这些要求，C语言的发明者就设置了以下变量：
1、
不同数据类型的变量；如：char
cHar,
int
iTimes,
flaot
faverage;
2、
全局变量或者叫全程变量；
3、
局部变量；
4、
静态变量：
静态全局变量和静态局部变量；关键词：static
5、
寄存器变量；关键词：register;
6、
外部变量：
关键词：extern;
C语言中，变量在内存中开辟地的大小由数据类型决定的，由于PC机中规定一个地址单元存一个字节，不同的数据类型的变量，为其分配的地址单元数是不一样的。C语言中除几种基本的数据类型外用户还可以自己定义所需要的数据类型：
1、
bool型
sizeof(bool):
1
2、
char型:
sizeof(char):
1
3、
short型:
sizeof(short):
2
4、
int型:
sizeof(int):
4
5、
long型:
sizeof(long):
4
6、
float型:
sizeof(float):
4
7、
double型:
sizeof(double):
8
8、
自定义型：如：
typedef
struct
tagMyData
{
char
cHar;
int
iTimes;
float
faverage;
}MyDatap;
sizeof(MyDatap):
12
char
szBuf[]="HELLO
C&C++!";
sizeof(szBuf):
13
局部变量和全局变量是相对而言的；如下：局部变量
int
itmp;
int
Get_Max(
const
int&
x,
const
int&
y,
const
int&
z
)
{
int
itmp;
if(x
>
y)
itmp
=
x;
else
itmp
=
y;
if(
itmp
>
z
)
return
itmp;
else
return
z;
}
在函数内部说明的变量为局部变量，只有在函数执行时，局部变量才存在，当函数执行完退出后，局部变量随之消失。也就是，当函数执行完退出后，原先在函数内定义的变量现在不能用，这通常由编译器保证，它会阻止编译通过。也就是说，原来为那个局部变量分配的内存，现在已经不属于它，它再无权访问了。如要再使用这些内存单元就必须从新定义变量来申请，只有分配给的变量才可访问它。否则，就会出错，如数组越界访问。
与局部变量不同，全局变量在整个程序都是可见的，可在整个程序运行过程中，对于任何一个程序都是可用的。全局变量的说明的位置在所有函数之外，但可被任何一个函数使用，读取或者写入。如下：全局变量
int
iCount,
bool
bForward;
int
iCount;
//全局变量；
bool
bForward;
//全局变量；
void
add(
void
);
void
dec(
void
);
void
man(void
)
{
while(
iCount
<
1000
&&
iCount
>
-1000)
{
add(
);
dec(
);
printf("COUNT:%d;\n",
iCount)
}
}
void
add(
void
)
{
if(
bForward
)
iCount++;
}
void
dec(
void
)
{
if(!bForward
)
iCount--;
}
可见，全局变量非常方便不同函数间数据共享，同样，任何函数在在使用数据时，都不敢保证数据是否已被修改。如果程序员无法保证这个，就尽量避免使用全局变量。
静态变量是分配在存储器中C程序所占据的数据段内，
C程序运行的整个过程中一直保留，不会被别的变量占用。静态变量可以定义成全局变量或局部变量，当定义为全局变量时，在它定义的程序的整个运行期间均存在并且保持原来的存储单元位置不会改变。那么既然有了全局变量为什么还要定义全局静态变量呢？看下边的示例：
模块1：
int
a;
static
int
b;
void
fun1(
void
)
{
……
fun2(
);
……
}
模块2：
extern
int
a;
satic
int
b;
void
fun2(
void
)
{
……
fun1(
);
……
}
分别编译，然后链接两个模块。。。。。。
模块1和模块2中，变量a为同一个变量；而变量b就不是同一个变量！虽然它们的的数据类型和名称均相同；就是因为有static；原因是，如果在全局变量说明前加上静态变量说明符static,它就会通知编译器该全局变量只在被定义的这个文件或模块中可见的。就是说，该静态全局变量在其他文件中是不可见的，在其他文件中的程序是不允许访问的。这在一定程度上减少了全局变量的副作用的影响。
同静态全局变量定义一样，当在局部变量名前加静态变量说明符static,该变量就定义为静态局部变量。编译器为该变量建立永久存储单元。永久是指C程序运行的整个过程中一直保留，不会被别的变量占用。静态局部变量和静态全局变量的根本区别在作用区域上，静态局部变量只在它被说明的函数或复合语句中有效，并且在两次函数调用期间仍然保存其值不变，即就是有记忆功能；它们的生命期是相同的，和C程序整个运行期同在。如下例：
#include
"stdafx.h"
void
counts(void);
void
countd(void)；
int
main(int
argc,
char*
argv[])
{
int
i
=
0;
while(
i++<10)
{
counts(
);
//使用静态局部变量
}
i
=
0;
while(
i++<10)
{
countd(
);
//使用局部变量
}
return
0;
}
void
counts(void)
//使用静态局部变量
{
static
int
isc
;
//未赋初值；
isc++;
printf("dsc
=
%d;\n",
dsc);
}
void
countd(void)
//使用局部变量
{
int
idc
=
0;
idd++;
printf("idc=%d;\n",idc);
}
执行结果为：
isc
=
1;
//使用静态局部变量
isc
=
2;
isc
=
3;
isc
=
4;
isc
=
5;
isc
=
6;
isc
=
7;
isc
=
8;
isc
=
9;
isc
=
10;
idc
=
1;
//使用局部变量
idc
=
1;
idc
=
1;
idc
=
1;
idc
=
1;
idc
=
1;
idc
=
1;
idc
=
1;
idc
=
1;
idc
=
1;
通过以上程序你也看得出：
1、
局部变量和静态局部变量的区别：记忆功能；
2、
静态局部变量只初始化一次，并且默认初始化为0；
静态变量在定义时若未被赋值，则编译程序将其初始化为0；
寄存器变量不像其他变量那样在内存中存放数据，而是在CPU的寄存器中暂存数据，使用寄存器变量比使用内存变量的操作速度快得多。只有整型和字符型变量可定义为寄存器变量。定义方式如下：
register
int
iTemp;
由于CPU中寄存器有限，尽量减少使用数量和和占用时间，用完马上释放；不能定义为全局变量，也不能定义在结构或者类中。
为了大型程序的管理，将一个大型的程序分成若干个独立的模块和文件分别编译，然后统一链接在一起。为了解决全局变量和函数的共用问题，就引入了extern关键字。这样只需在一个文件中定义全局变量和函数，在另一个文件中要用到这些变量和函数时，只需将那个文件中的变量和函数说明表复制过来，在前面加上extern，告诉编译器，这些变量和函数已经在别的文件中定义说明，在此不必再定义说明了。
王佰营
徐丽红
任何一种编程语言都离不开变量，特别是数据处理型程序，变量的使用非常频繁，没有变量参与程序甚至无法编制，即使编制运行后的意义也不大。变量之所以重要，是因为变量是编程语言中数据的符号标识和载体。
C语言是一种应用广泛的善于实现控制的语言，变量在C语言中的应用更是灵活多变。那么变量究竟是什么呢？变量是内存或寄存器中用一个标识符命名的存储单元，可以用来存储一个特定类型的数据，并且数据的值在程序运行过程中可以进行修改。可见，变量首先是一个标识符或者名称，就像一个客房的编号一样，有了这个编号我们在交流中就可方便言表，否则，我们只可意会，那多不方便。为了方便，我们在给变量命名时，最好能符合大多数人的习惯，基本可以望名知义，便于交流和维护；其次，变量是唯一确定的对应内存若干存储单元或者某个寄存器。这些是编译器来保证的，用户一般不用费心。
程序员一旦定义了变量，那么，变量就至少可为我们提供两个信息：一是变量的地址，即就是，操作系统为变量在内存中分配的若干内存的首地址；二是变量的值，也就是，变量在内存中所分配的那些内存单元中所存放的数据。
由于程序的多样需要，我们对变量也有各种各样的要求，比如：变量的生命期，变量的初始状态，变量的有效区域，变量的开辟地和变量的开辟区域的大小等等；为了满足这些要求，C语言的发明者就设置了以下变量：
1、
不同数据类型的变量；如：char
cHar,
int
iTimes,
flaot
faverage;
2、
全局变量或者叫全程变量；
3、
局部变量；
4、
静态变量：
静态全局变量和静态局部变量；关键词：static
5、
寄存器变量；关键词：register;
6、
外部变量：
关键词：extern;
C语言中，变量在内存中开辟地的大小由数据类型决定的，由于PC机中规定一个地址单元存一个字节，不同的数据类型的变量，为其分配的地址单元数是不一样的。C语言中除几种基本的数据类型外用户还可以自己定义所需要的数据类型：
1、
bool型
sizeof(bool):
1
2、
char型:
sizeof(char):
1
3、
short型:
sizeof(short):
2
4、
int型:
sizeof(int):
4
5、
long型:
sizeof(long):
4
6、
float型:
sizeof(float):
4
7、
double型:
sizeof(double):
8
8、
自定义型：如：
typedef
struct
tagMyData
{
char
cHar;
int
iTimes;
float
faverage;
}MyDatap;
sizeof(MyDatap):
12
char
szBuf[]="HELLO
C&C++!";
sizeof(szBuf):
13
局部变量和全局变量是相对而言的；如下：局部变量
int
itmp;
int
Get_Max(
const
int&
x,
const
int&
y,
const
int&
z
)
{
int
itmp;
if(x
>
y)
itmp
=
x;
else
itmp
=
y;
if(
itmp
>
z
)
return
itmp;
else
return
z;
}
在函数内部说明的变量为局部变量，只有在函数执行时，局部变量才存在，当函数执行完退出后，局部变量随之消失。也就是，当函数执行完退出后，原先在函数内定义的变量现在不能用，这通常由编译器保证，它会阻止编译通过。也就是说，原来为那个局部变量分配的内存，现在已经不属于它，它再无权访问了。如要再使用这些内存单元就必须从新定义变量来申请，只有分配给的变量才可访问它。否则，就会出错，如数组越界访问。
与局部变量不同，全局变量在整个程序都是可见的，可在整个程序运行过程中，对于任何一个程序都是可用的。全局变量的说明的位置在所有函数之外，但可被任何一个函数使用，读取或者写入。如下：全局变量
int
iCount,
bool
bForward;
int
iCount;
//全局变量；
bool
bForward;
//全局变量；
void
add(
void
);
void
dec(
void
);
void
man(void
)
{
while(
iCount
<
1000
&&
iCount
>
-1000)
{
add(
);
dec(
);
printf("COUNT:%d;\n",
iCount)
}
}
void
add(
void
)
{
if(
bForward
)
iCount++;
}
void
dec(
void
)
{
if(!bForward
)
iCount--;
}
可见，全局变量非常方便不同函数间数据共享，同样，任何函数在在使用数据时，都不敢保证数据是否已被修改。如果程序员无法保证这个，就尽量避免使用全局变量。
静态变量是分配在存储器中C程序所占据的数据段内，
C程序运行的整个过程中一直保留，不会被别的变量占用。静态变量可以定义成全局变量或局部变量，当定义为全局变量时，在它定义的程序的整个运行期间均存在并且保持原来的存储单元位置不会改变。那么既然有了全局变量为什么还要定义全局静态变量呢？看下边的示例：
模块1：
int
a;
static
int
b;
void
fun1(
void
)
{
……
fun2(
);
……
}
模块2：
extern
int
a;
satic
int
b;
void
fun2(
void
)
{
……
fun1(
);
……
}
分别编译，然后链接两个模块。。。。。。
模块1和模块2中，变量a为同一个变量；而变量b就不是同一个变量！虽然它们的的数据类型和名称均相同；就是因为有static；原因是，如果在全局变量说明前加上静态变量说明符static,它就会通知编译器该全局变量只在被定义的这个文件或模块中可见的。就是说，该静态全局变量在其他文件中是不可见的，在其他文件中的程序是不允许访问的。这在一定程度上减少了全局变量的副作用的影响。
同静态全局变量定义一样，当在局部变量名前加静态变量说明符static,该变量就定义为静态局部变量。编译器为该变量建立永久存储单元。永久是指C程序运行的整个过程中一直保留，不会被别的变量占用。静态局部变量和静态全局变量的根本区别在作用区域上，静态局部变量只在它被说明的函数或复合语句中有效，并且在两次函数调用期间仍然保存其值不变，即就是有记忆功能；它们的生命期是相同的，和C程序整个运行期同在。如下例：
#include
"stdafx.h"
void
counts(void);
void
countd(void)；
int
main(int
argc,
char*
argv[])
{
int
i
=
0;
while(
i++<10)
{
counts(
);
//使用静态局部变量
}
i
=
0;
while(
i++<10)
{
countd(
);
//使用局部变量
}
return
0;
}
void
counts(void)
//使用静态局部变量
{
static
int
isc
;
//未赋初值；
isc++;
printf("dsc
=
%d;\n",
dsc);
}
void
countd(void)
//使用局部变量
{
int
idc
=
0;
idd++;
printf("idc=%d;\n",idc);
}
执行结果为：
isc
=
1;
//使用静态局部变量
isc
=
2;
isc
=
3;
isc
=
4;
isc
=
5;
isc
=
6;
isc
=
7;
isc
=
8;
isc
=
9;
isc
=
10;
idc
=
1;
//使用局部变量
idc
=
1;
idc
=
1;
idc
=
1;
idc
=
1;
idc
=
1;
idc
=
1;
idc
=
1;
idc
=
1;
idc
=
1;
通过以上程序你也看得出：
1、
局部变量和静态局部变量的区别：记忆功能；
2、
静态局部变量只初始化一次，并且默认初始化为0；
静态变量在定义时若未被赋值，则编译程序将其初始化为0；
寄存器变量不像其他变量那样在内存中存放数据，而是在CPU的寄存器中暂存数据，使用寄存器变量比使用内存变量的操作速度快得多。只有整型和字符型变量可定义为寄存器变量。定义方式如下：
register
int
iTemp;
由于CPU中寄存器有限，尽量减少使用数量和和占用时间，用完马上释放；不能定义为全局变量，也不能定义在结构或者类中。
为了大型程序的管理，将一个大型的程序分成若干个独立的模块和文件分别编译，然后统一链接在一起。为了解决全局变量和函数的共用问题，就引入了extern关键字。这样只需在一个文件中定义全局变量和函数，在另一个文件中要用到这些变量和函数时，只需将那个文件中的变量和函数说明表复制过来，在前面加上extern，告诉编译器，这些变量和函数已经在别的文件中定义说明，在此不必再定义说明了。
第3个回答 2018-06-26
c语言int类型用两个字节16位存贮 只能存储-32768~32767 存储9位数可用long int 或浮点来存贮float、double 一、整型数说明 加上不同的修饰符, 整型数有以下几种类型; signed short int 有符号短整型数说明。简写为short或int, 字长为2 字节共16位二进制数, 数的范围是-32768~32767。 signed long int 有符号长整型数说明。简写为long, 字长为4字节共 32位二进制数, 数的范围是-2147483648~2147483647。 unsigned short int 无符号短整型数说明。简写为unsigned int, 字长 为2字节共16位二进制数, 数的范围是0~65535。 unsigned long int 无符号长整型数说明。简写为unsigned long, 字长 为4字节共32位二进制数, 数的范围是0~4294967295。 一、浮点数说明 Turbo C中有以下两种类型的浮点数: float 单浮点数。字长为4 个字节共32位二进制数,数的范围是3.4x10-38E~3.4x10+38E。 double 双浮点数。字长为 8个字节共 64位二进制数,数的范围是1.7x10-308E~1.7x10+308E。本回答被网友采纳
第4个回答 2020-01-23
从初始化角度来看，所有的静态变量都在编译时期初始化完毕（局部静态对象就不一样了(c++的#^_^#)，这里不讨论），即使你不给他初始化。
从作用域范围来看，全局静态变量只在本模块内有效(就是在你定义的一个.h和你包含的.c内有效)，局部静态对象只在相应的局部内有效(在哪函数定义的，作用域就在那个函数定义开始的地方至函数结束)
从生命周期来看，静态变量、全局变量的生命周期内都有效，而局部变量(动态)只在相应定义的函数体内有效,
从定义的方式来看,静态变量可以定义在.h文件中,而全局变量尽量不要定义在.h中不然容易出现重复定义错误.
从作用域范围来看，全局静态变量只在本模块内有效(就是在你定义的一个.h和你包含的.c内有效)，局部静态对象只在相应的局部内有效(在哪函数定义的，作用域就在那个函数定义开始的地方至函数结束)
从生命周期来看，静态变量、全局变量的生命周期内都有效，而局部变量(动态)只在相应定义的函数体内有效,
从定义的方式来看,静态变量可以定义在.h文件中,而全局变量尽量不要定义在.h中不然容易出现重复定义错误.
相似回答