C语言程序设计：讲座 03-21(2)

1、1 常量与变量常量与变量定义符号常量定义符号常量整型常量整型常量实型常量实型常量整型变量整型变量实型变量实型变量先定义后使用先定义后使用变量名，也是一种标识符，只能由字母、数变量名，也是一种标识符，只能由字母、数字和下划线组成，以字母或下划线开头。字和下划线组成，以字母或下划线开头。2 3.3变量变量根据变量所持有的数据的性质不同，而分为各种数据类型；根据变量所持有的数据的性质不同，而分为各种数据类型；变量是程序中其值发生变化的量，变量是程序中其值发生变化的量，C语言中的变量有以下三种属性：语言中的变量有以下三种属性：整型变量整型变量实型变量实型变量字符变量字符变量字符串变量字符串变量 根据变

2、量的存储方式的不同，而分为下面各种存储类型；根据变量的存储方式的不同，而分为下面各种存储类型；auto堆栈型或自动型堆栈型或自动型register寄存器型寄存器型static静态型静态型extern外部参照型外部参照型变量在使用时有一定的有效范围。变量在使用时有一定的有效范围。3 3.3变量变量有关变量主要内容：有关变量主要内容：p变量和变量的地址变量和变量的地址p变量的数据类型变量的数据类型p数据类型的转换数据类型的转换p变量的存储类型变量的存储类型p变量的使用范围变量的使用范围p变量的初始化变量的初始化4变量名：用户根据其功能任意命名，但变量名不能与变量名：用户根据其功能任意命名，但变量名

3、不能与C的保留字的保留字（关键字）相同。一般的（关键字）相同。一般的C编译系统仅对其前编译系统仅对其前8个字符作为有效字个字符作为有效字符处理。符处理。变量名在内存中占有一个存储单元，并对应一个地址。变量名在内存中占有一个存储单元，并对应一个地址。a变量地址变量地址变量（值）变量（值） 3.3.1变量和变量的地址变量和变量的地址在程序运行时，变量的数值存储在一定的存储空间中。在程序运行时，变量的数值存储在一定的存储空间中。存储某变量的内存空间的首存储某变量的内存空间的首地址地址，称为，称为变量的地址变量的地址。例例a内存分配：8400a 存储的首地址为存储的首地址为8400 &a的值为

4、的值为8400. 变量的地址用变量名前加一个变量的地址用变量名前加一个&符号来标示，符号来标示，&是一个标示取地址的运算符号是一个标示取地址的运算符号 5例例 如，一组变量的定义：如，一组变量的定义： x; a, b, c; pi=; score; 变量的定义变量的定义C使用变量的原则：使用变量的原则： “先定义，再使用先定义，再使用”目的：通知编译程序为变量分配目的：通知编译程序为变量分配 适当的存储空间适当的存储空间定义格式定义格式: 数据类型数据类型 变量名表；变量名表；变量的取值范围变量的取值范围存储空间大小（字节数）存储空间大小（字节数）合法标识符合法标识符定义同时可

5、以赋初值（初始化）定义同时可以赋初值（初始化） 2.3.2变量的数据类型变量的数据类型如果在定义变量的数据类型的时候，也要说明变量的存储类型？如果在定义变量的数据类型的时候，也要说明变量的存储类型？存储类型存储类型 数据类型数据类型 变量名表；变量名表；;变量说明要在程序的数据说明部分或者函数的参数说明部分进行。变量说明要在程序的数据说明部分或者函数的参数说明部分进行。61)类型长度与机器硬件有关类型长度与机器硬件有关2)在机器中，正数用在机器中，正数用二进制二进制原码原码表示，负数用表示，负数用二进制二进制 补码补码表示。表示。1.1.整型变量整型变量3.3.2变量的数据类型变量的数据类型整

6、型数据在内存中的存放形式整型数据在内存中的存放形式（二进制）（二进制）int i; /* 定义为整型变量定义为整型变量 */i=10; /* 给给i赋以整数赋以整数10 */( 10 )10 ( 1010 )2数值是以补码数值是以补码(complement) 表示的。一个正数的补码和其原码的形式相同。表示的。一个正数的补码和其原码的形式相同。73.3.2变量的数据类型变量的数据类型内存中负数用内存中负数用二进制二进制补码补码表示。表示。求负数的补码的方法是：将该数的绝对值的二进制形式，按位取反再加求负数的补码的方法是：将该数的绝对值的二进制形式，按位取反再加1。求求-10的补码：的补码：取取-

7、10的绝对值的绝对值10；10的绝对值的二进制形式为的绝对值的二进制形式为1010；对对1010取反得取反得1111111111110101(一个整数占一个整数占16位位)；再加再加1得得1111111111110110最左面的一位是最左面的一位是表示符号的，该表示符号的，该位为位为0，表示数值，表示数值为正；为为正；为1则数则数值为负。值为负。83.3.2变量的数据类型变量的数据类型整型变量的分类整型变量的分类(1) 基本整型，以基本整型，以int表示。表示。(2) 短整型，短整型， 以以short int表示，或以表示，或以short表示。表示。(3) 长整型，长整型， 以以long in

8、t表示，或以表示，或以long表示。表示。整型变量的整型变量的基本类型符基本类型符为为int。可以根据数值的范围将变量定义为基本整型、短整型或长整型。可以根据数值的范围将变量定义为基本整型、短整型或长整型。在在turbo c中一个中一个int型的变量的值范围为型的变量的值范围为-215(215-1) ，即，即-3276832767。 为了充分利用变量的表数范围，可以将变量定义为为了充分利用变量的表数范围，可以将变量定义为“无符号无符号”类型。类型。 有符号基本整型有符号基本整型 signed int 无符号基本整型无符号基本整型 unsigned int有符号短整型有符号短整型 signed

9、short int无符号短整型无符号短整型 unsigned short int有符号长整型有符号长整型 signed long int无符号长整型无符号长整型 unsigned long int93.3.2变量的数据类型变量的数据类型整型变量的分类整型变量的分类 如果指定如果指定unsigned，为无符号型，存储单元中全部二进位，为无符号型，存储单元中全部二进位(bit)用作存放数本身，用作存放数本身， 而不包括符号。而不包括符号。 无符号型变量只能存放不带符号的整数。无符号型变量只能存放不带符号的整数。 一个无符号整型变量中可以存放的正数的范围比一般整型变量中正数的范围扩大一倍。一个无符号

10、整型变量中可以存放的正数的范围比一般整型变量中正数的范围扩大一倍。 定义定义a和和b两个变量两个变量:int a;unsigned int b;例例则则变量变量a的数值范围为的数值范围为-3276832767。而变量。而变量b的数值范围为的数值范围为065535。103.3.2变量的数据类型变量的数据类型整型变量的分类整型变量的分类113.3.2变量的数据类型变量的数据类型整型数据的溢出整型数据的溢出例例 main( ) int a，b; a=32767; b=a+1; printf(%d，%d，a，b); 运行结果为运行结果为:32767，-32768b改成改成long型就可得到预期的结果型

11、就可得到预期的结果32768- 32768 的补码形式的补码形式123.3.2变量的数据类型变量的数据类型2.实型变量（浮点型变量）实型变量（浮点型变量）i.存放包含小数位的值存放包含小数位的值ii.分单精度分单精度(float)和双精度和双精度(double)两种两种iii.float 接收七位有效数字，接收七位有效数字，double型接收型接收15位或位或16位，与位，与机器硬件有关机器硬件有关浮点型常量既可以赋给浮点型常量既可以赋给float型变量，也可以赋给型变量，也可以赋给double型变量在型变量在 赋值时，将根据赋值时，将根据变量的类型变量的类型来来截取截取相应的相应的有效位数有

12、效位数。例：例： float a； double b； a=123456.789; b=123456.789;正确的结果是正确的结果是: a的值为：的值为：123456.7 b的值为：的值为：123456.789133.3.2变量的数据类型变量的数据类型实型变量在内存中的存放形式实型变量在内存中的存放形式 在常用的微机系统中，一个实型数据在内存中占在常用的微机系统中，一个实型数据在内存中占4个字节个字节(32位位)。实型数据是按照指数形式存储的。实型数据是按照指数形式存储的。 /*系统把一个实型数据分成系统把一个实型数据分成小数部分小数部分和和指数部分指数部分，分别存放分别存放。*/在在4个字

13、节个字节(32位位)中，用多少位中，用多少位来表示小数部分，多少位来表来表示小数部分，多少位来表示指数部分，标准示指数部分，标准C并无具体并无具体规定，由各规定，由各C编译系统自定。编译系统自定。143.3.2变量的数据类型变量的数据类型3.字符型变量字符型变量在一个字节的存储空间中，存放在一个字节的存储空间中，存放“表示表示”单个字符的整型数单个字符的整型数(ASCII码码)字符变量的定义形式如下：字符变量的定义形式如下：charc1，c2；一般用一般用unsigned char (0255)定义字符变量即可定义字符变量即可 可直接参与整型变量的运算可直接参与整型变量的运算例：例： char

14、 ch= A;ch+1 B等价：等价： 65+1 66又又 ch+32 97 a例：例： 1) char ch=A; 则则ch中存放的是中存放的是ASCII码码65 A 65 2) char ch=49; 由于由于49是是1的的ASCII码码 所以表示字符所以表示字符1 思考一下思考一下 下列定义中下列定义中c1和和c2的结果是否等价的结果是否等价,为什么为什么? char c1=a; short int c2=97;153.3.2变量的数据类型变量的数据类型字符型变量在内存中的存放形式字符型变量在内存中的存放形式将一个字符常量放到一个字符变量中，将一个字符常量放到一个字符变量中，实际上并不是

15、把该字符本身放到内存单元中去，实际上并不是把该字符本身放到内存单元中去，而是将该字符的相应的而是将该字符的相应的ASCII代码放到存储单元中。代码放到存储单元中。例例char c1=a;char c2=b;c1=97c2=98163.3.3不同类型数据间的转换不同类型数据间的转换类型转换的概念类型转换的概念在程序运行中，一种数据的类型改变成另一种数据类型在程序运行中，一种数据的类型改变成另一种数据类型类型转换两种方式类型转换两种方式a)隐式转换隐式转换自动类型转换自动类型转换b)显式转换显式转换强制类型转换强制类型转换隐式转换发生在下列三种情况隐式转换发生在下列三种情况1.混合运算（算术转换）

16、混合运算（算术转换）2.赋值运算赋值运算3.数据输入输出数据输入输出17一一. .算术转换（算术转换（隐式转换隐式转换）当不同类型数据混合运算时，自动进行的转换当不同类型数据混合运算时，自动进行的转换3.3.3不同类型数据间的转换不同类型数据间的转换语言允许整型、单精度浮点型和双精度浮点型数据之间进语言允许整型、单精度浮点型和双精度浮点型数据之间进行混合运算，由于字符型数据可以和整型数据通用，所以，下行混合运算，由于字符型数据可以和整型数据通用，所以，下列表达式是合法的：列表达式是合法的： B+3.14*560-92转换原则转换原则第一点：带第一点：带* *为无条件的转换为无条件的转换第二点：

17、视周围类型的高低第二点：视周围类型的高低 采取采取“向高看齐向高看齐”183.3.3不同类型数据间的转换不同类型数据间的转换一一. .算术转换（算术转换（隐式转换隐式转换）doublelong 2.0 2.519二二. .强制类型转换（强制类型转换（显式转换显式转换） 在程序中强制地进行类型转换在程序中强制地进行类型转换 使用格式使用格式 ( (类型名类型名) ) 表达式表达式 精度问题：较高类型向较低类型转换时，可能发生损失精度问题：较高类型向较低类型转换时，可能发生损失基本类型或指针类型基本类型或指针类型 常量、变量、表达式常量、变量、表达式 3.3.3不同类型数据间的转换不同类型数据间的

18、转换例：例：sqrt()函数调用时，要求参数是函数调用时，要求参数是double型型数据。而变量数据。而变量n是是int型，且作为该函数的参数型，且作为该函数的参数使用时，就必须强制转换使用时，就必须强制转换n的数据类型。的数据类型。 sqrt(double) n)203.3.3不同类型数据间的转换不同类型数据间的转换NOTE无论是自动地还是强制地实现数据类型的转换，无论是自动地还是强制地实现数据类型的转换，仅仅是为本次运算或赋值的需要而对变量的数仅仅是为本次运算或赋值的需要而对变量的数据长度进行一时性的转换，并不能改变数据说据长度进行一时性的转换，并不能改变数据说明时对该变量规定的数据类型。

19、明时对该变量规定的数据类型。213.3.4变量的存储类型变量的存储类型变量的存储类型规定了该变量数据的存储区域。变量的存储类型规定了该变量数据的存储区域。C语言的变量共语言的变量共有四种存储类型：有四种存储类型：auto堆栈型或自动型堆栈型或自动型register寄存器型寄存器型static静态型静态型extern外部参照型外部参照型223.3.4变量的存储类型变量的存储类型一一. auto堆栈型或自动型堆栈型或自动型p存储在内存的堆栈区；存储在内存的堆栈区；p它只是一临时性存储，并不长期占用内存，其存储空间可以被若干变量多次覆盖；它只是一临时性存储，并不长期占用内存，其存储空间可以被若干变量

20、多次覆盖；pC语言中大量使用的变量是语言中大量使用的变量是auto型，型， auto在写程序时通常被省略。在写程序时通常被省略。例例1：int i, j;其中其中i，j都是都是auto型，型，占用内存如图：占用内存如图：堆栈堆栈ij例例2：当例当例1结束后，又有另一程序如：结束后，又有另一程序如：char a, b; a，b是是auto型，型，它可以覆盖它可以覆盖i所占用的内存。所占用的内存。堆栈堆栈abj233.3.4变量的存储类型变量的存储类型二二. register寄存器型寄存器型p存储在存储在CPU的通用寄存器中，即为的通用寄存器中，即为16位；位；p数据类型为数据类型为long, d

21、ouble和和float的变量不能设为的变量不能设为register型；型；例例1：register char c;在通用寄存器中存储如图在通用寄存器中存储如图c通用寄存器通用寄存器寄存器寄存器1寄存器寄存器2在在C程序中设定程序中设定register型变量的个数型变量的个数不是任意不是任意的，通常的，通常两个两个左右。左右。编译系统对于超过编译系统对于超过CPU中可使用的通用寄存器个数的中可使用的通用寄存器个数的register变量作变量作auto变量变量。例例2：register char a, b, c; 存储如图存储如图通用寄存器通用寄存器ab寄存器寄存器1寄存器寄存器2c堆栈堆栈24

22、3.3.4变量的存储类型变量的存储类型三三. static静态型静态型p存储在一般的内存区域中；存储在一般的内存区域中；p在数据说明时被分配了一定的内存空间；在数据说明时被分配了一定的内存空间；p分配的空间在整个程序运行中，自始至终都归该变量使用。分配的空间在整个程序运行中，自始至终都归该变量使用。例例1：static int n; 在内存中存储如在内存中存储如图图内存内存n例例2：在例在例1执行后，又有执行后，又有static int m; 存储如图存储如图内存内存nm253.3.4变量的存储类型变量的存储类型四四. extern外部型外部型p外部变量一般用于在程序的多个编译单位之间传递数据

23、；外部变量一般用于在程序的多个编译单位之间传递数据； p指定指定extern型的变量是在其它编译单位的源文件中定义的型的变量是在其它编译单位的源文件中定义的 ；p存储空间需要参照本身的编译单位外部而决定，外部参照型存储空间需要参照本身的编译单位外部而决定，外部参照型 。263.3.5变量的使用范围变量的使用范围p变量的变量的存储区域存储区域和变量在和变量在程序中说明的位置程序中说明的位置决定了变量的使用范围。决定了变量的使用范围。p变量的变量的可见性（作用域）可见性（作用域）：变量的：变量的有效使用范围有效使用范围，分为：全局可见和局部可见两种特性。，分为：全局可见和局部可见两种特性。内部变量

24、：内部变量：在函数内部或某大括弧包围的程序内部说明的变量。在函数内部或某大括弧包围的程序内部说明的变量。 可以是可以是auto型，型，register型，其中型，其中auto型可以缺省；型可以缺省；auto型，型，register型是局部可见、局部寿命，型是局部可见、局部寿命，static是局部可见、全局寿命。是局部可见、全局寿命。外部变量：外部变量：在所有函数外部说明的变量。在所有函数外部说明的变量。 可以是可以是static型和缺省存储类型的变量，是全局可见、全局寿型和缺省存储类型的变量，是全局可见、全局寿命。命。p变量的变量的生存期生存期：变量在程序运行期间的寿命，分为：全局寿命和局部寿

25、命两种特性。：变量在程序运行期间的寿命，分为：全局寿命和局部寿命两种特性。273.3.5变量的使用范围变量的使用范围全局寿命：全局寿命：其寿命存在与其寿命存在与整个程序的运行整个程序的运行过程中的变量。过程中的变量。 如如static型的变量，外部变量。型的变量，外部变量。局部寿命：局部寿命：函数开始调用时为变量分配存储空间，函数结束时释放这函数开始调用时为变量分配存储空间，函数结束时释放这些空间。些空间。 如如auto型，型，register型变量。型变量。28int b;main()int i;static int a;i = 1; a = 10; b = 5;printf(“-MAIN-

26、n”);printf(“i:%d a:%d b:%dn”,i, a, b);other();printf(“-MAIN-n”);printf(“i:%d a:%d b:%dn”,i, a, b);other()int i;static int a;i = 16; a = 100;printf(“-OTHER-n”);printf(“i:%d a:%d b:%dn”,i, a, b);3.3.5变量的使用范围变量的使用范围29int b;main()int i;static int a;i = 1; a = 10; b = 5;printf(“-MAIN-n”);printf(“i:%d a:%

27、d b:%dn”,i, a, b);other();printf(“-MAIN-n”);printf(“i:%d a:%d b:%dn”,i, a, b);other()int i;static int a;i = 16; a = 100;printf(“-OTHER-n”);printf(“i:%d a:%d b:%dn”,i, a, b);3.3.5变量的使用范围变量的使用范围定义外部变量定义外部变量b，在整个程序过程，在整个程序过程中起作用中起作用30int b;main()int i;static int a;i = 1; a = 10; b = 5;printf(“-MAIN-n”)

28、;printf(“i:%d a:%d b:%dn”,i, a, b);other();printf(“-MAIN-n”);printf(“i:%d a:%d b:%dn”,i, a, b);other()int i;static int a;i = 16; a = 100;printf(“-OTHER-n”);printf(“i:%d a:%d b:%dn”,i, a, b);3.3.5变量的使用范围变量的使用范围i为为auto型内部变量，型内部变量，只在只在main内起作用。内起作用。31int b;main()int i;static int a;i = 1; a = 10; b = 5;

29、printf(“-MAIN-n”);printf(“i:%d a:%d b:%dn”,i, a, b);other();printf(“-MAIN-n”);printf(“i:%d a:%d b:%dn”,i, a, b);other()int i;static int a;i = 16; a = 100;printf(“-OTHER-n”);printf(“i:%d a:%d b:%dn”,i, a, b);3.3.5变量的使用范围变量的使用范围a为为static型内部变量型内部变量只在只在main函数内起作用函数内起作用具备具备全局寿命全局寿命和和局部可见性局部可见性32int b;mai

30、n()int i;static int a;i = 1; a = 10; b = 5;printf(“-MAIN-n”);printf(“i:%d a:%d b:%dn”,i, a, b);other();printf(“-MAIN-n”);printf(“i:%d a:%d b:%dn”,i, a, b);other()int i;static int a;i = 16; a = 100;printf(“-OTHER-n”);printf(“i:%d a:%d b:%dn”,i, a, b);3.3.5变量的使用范围变量的使用范围运行结果：运行结果：-MAIN-i:1 a:10 b:533i

31、nt b;main()int i;static int a;i = 1; a = 10; b = 5;printf(“-MAIN-n”);printf(“i:%d a:%d b:%dn”,i, a, b);other();printf(“-MAIN-n”);printf(“i:%d a:%d b:%dn”,i, a, b);other()int i;static int a;i = 16; a = 100;printf(“-OTHER-n”);printf(“i:%d a:%d b:%dn”,i, a, b);3.3.5变量的使用范围变量的使用范围调用函数调用函数other()运行结果：运行结

32、果：-MAIN-i:1 a:10 b:534int b;main()int i;static int a;i = 1; a = 10; b = 5;printf(“-MAIN-n”);printf(“i:%d a:%d b:%dn”,i, a, b);other();printf(“-MAIN-n”);printf(“i:%d a:%d b:%dn”,i, a, b);other()int i;static int a;i = 16; a = 100;printf(“-OTHER-n”);printf(“i:%d a:%d b:%dn”,i, a, b);3.3.5变量的使用范围变量的使用范围

33、 i为为auto内部变量，只在内部变量，只在other函数内部起作用，函数内部起作用，与与main函数内的函数内的i不冲突。不冲突。运行结果：运行结果：-MAIN-i:1 a:10 b:535int b;main()int i;static int a;i = 1; a = 10; b = 5;printf(“-MAIN-n”);printf(“i:%d a:%d b:%dn”,i, a, b);other();printf(“-MAIN-n”);printf(“i:%d a:%d b:%dn”,i, a, b);other()int i;static int a;i = 16; a = 10

34、0;printf(“-OTHER-n”);printf(“i:%d a:%d b:%dn”,i, a, b);3.3.5变量的使用范围变量的使用范围运行结果：运行结果：-MAIN-i:1 a:10 b:5 a为为static型内部变量，只在型内部变量，只在other函数内部起作用，函数内部起作用，与与main函数内的函数内的a不冲突。不冲突。具备具备全局寿命全局寿命和和局部可见性局部可见性36int b;main()int i;static int a;i = 1; a = 10; b = 5;printf(“-MAIN-n”);printf(“i:%d a:%d b:%dn”,i, a, b

35、);other();printf(“-MAIN-n”);printf(“i:%d a:%d b:%dn”,i, a, b);other()int i;static int a;i = 16; a = 100;printf(“-OTHER-n”);printf(“i:%d a:%d b:%dn”,i, a, b);3.3.5变量的使用范围变量的使用范围调用结束返回主函数调用结束返回主函数main()运行结果：运行结果：-MAIN-i:1 a:10 b:5-OTHER-i:16 a:100 b:537int b;main()int i;static int a;i = 1; a = 10; b =

36、 5;printf(“-MAIN-n”);printf(“i:%d a:%d b:%dn”,i, a, b);other();printf(“-MAIN-n”);printf(“i:%d a:%d b:%dn”,i, a, b);other()int i;static int a;i = 16; a = 100;printf(“-OTHER-n”);printf(“i:%d a:%d b:%dn”,i, a, b);3.3.5变量的使用范围变量的使用范围主函数主函数main()运行结束运行结束运行结果：运行结果：-MAIN-i:1 a:10 b:5-OTHER-i:16 a:100 b:5-M

37、AIN-i:1 a:10 b:5383.3.5变量的使用范围变量的使用范围 总结总结3、外部变量：、外部变量：外部变量外部变量可以是可以是static型变量和缺省存储类型的变量，型变量和缺省存储类型的变量， 具备具备全局寿命全局寿命和和全局可见性全局可见性。1、auto型，型，register型变量是型变量是内部变量内部变量，具备，具备局部寿命局部寿命和和局部可见性局部可见性。2、static型变量可以是型变量可以是内部变量内部变量也可以是也可以是外部变量外部变量，但无论是内部，但无论是内部 变量还是外部变量，它具备全局寿命，变量还是外部变量，它具备全局寿命，static 型内部变量具有型内部

38、变量具有全局寿命全局寿命和和 局部可见性局部可见性。393.3.6变量的初始化变量的初始化要点要点 没有进行初始化的没有进行初始化的auto型和型和register型变量，型变量， 不能直接在程序中使用，但可被多次赋值。不能直接在程序中使用，但可被多次赋值。 static型变量和外部变量不进行初始化的话，型变量和外部变量不进行初始化的话， 自动赋予零值，自动赋予零值，static型变量初始化只进行一次。型变量初始化只进行一次。 指定为指定为extern型的变量不能进行初始化。型的变量不能进行初始化。 static型变量和外部变量必须用常量进行初始型变量和外部变量必须用常量进行初始 化，而化，而

39、auto型和型和register型变量则可以用常量和型变量则可以用常量和 变量进行初始化。变量进行初始化。p 变量在说明的同时，可以被赋予变量在说明的同时，可以被赋予初值初值，这称为变量的，这称为变量的初始化初始化。403.3.6变量的初始化变量的初始化int i = 1;main()static int a; register int b= -10; int c = 0;printf(“-MAIN-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);c = c + 8;other();printf(“-MAIN-n”);printf(“i:%da:%db:%dc:

40、%dn”,i,a,b,c);i = i + 10;other();other()static int a = 2; static int b; int c = 10;a = a + 2;i = i + 32;c = c + 5;printf(“-OTHER-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);b = a;413.3.6变量的初始化变量的初始化int i = 1;main()static int a; register int b= -10; int c = 0;printf(“-MAIN-n”);printf(“i:%da:%db:%dc:%dn”,

41、i,a,b,c);c = c + 8;other();printf(“-MAIN-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);i = i + 10;other();other()static int a = 2; static int b; int c = 10;a = a + 2;i = i + 32;c = c + 5;printf(“-OTHER-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);b = a;变量变量i为外部变量，为外部变量，赋值为赋值为1423.3.6变量的初始化变量的初始化int i = 1;main(

42、)static int a; register int b= -10; int c = 0;printf(“-MAIN-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);c = c + 8;other();printf(“-MAIN-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);i = i + 10;other();other()static int a = 2; static int b; int c = 10;a = a + 2;i = i + 32;c = c + 5;printf(“-OTHER-n”);printf(“i

43、:%da:%db:%dc:%dn”,i,a,b,c);b = a;a为为static型内部变量，会型内部变量，会自动赋值为自动赋值为0；b为为register型内部变量，赋值为型内部变量，赋值为-10；c为为auto型内部变量，初值型内部变量，初值为为0。433.3.6变量的初始化变量的初始化int i = 1;main()static int a; register int b= -10; int c = 0;printf(“-MAIN-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);c = c + 8;other();printf(“-MAIN-n”);pr

44、intf(“i:%da:%db:%dc:%dn”,i,a,b,c);i = i + 10;other();other()static int a = 2; static int b; int c = 10;a = a + 2;i = i + 32;c = c + 5;printf(“-OTHER-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);b = a;运行结果：运行结果：-MAIN-i:1 a:0 b:-10 c:0443.3.6变量的初始化变量的初始化int i = 1;main()static int a; register int b= -10; in

45、t c = 0;printf(“-MAIN-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);c = c + 8; / c=8other();printf(“-MAIN-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);i = i + 10;other();other()static int a = 2; static int b; int c = 10;a = a + 2;i = i + 32;c = c + 5;printf(“-OTHER-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);b = a

46、;调用函数调用函数other()运行结果：运行结果：-MAIN-i:1 a:0 b:-10 c:0453.3.6变量的初始化变量的初始化int i = 1;main()static int a; register int b= -10; int c = 0;printf(“-MAIN-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);c = c + 8; / c=8other();printf(“-MAIN-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);i = i + 10;other();other()static int a

47、= 2; static int b; int c = 10;a = a + 2;i = i + 32;c = c + 5;printf(“-OTHER-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);b = a;a为为static型内部变量，初值型内部变量，初值为为2；b为为static型内部变量，型内部变量，自动赋值为自动赋值为0；c为为auto型内型内部变量，初值为部变量，初值为10。运行结果：运行结果：-MAIN-i:1 a:0 b:-10 c:0463.3.6变量的初始化变量的初始化int i = 1;main()static int a; regist

48、er int b= -10; int c = 0;printf(“-MAIN-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);c = c + 8; / c=8other();printf(“-MAIN-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);i = i + 10;other();other()static int a = 2; static int b; int c = 10;a = a + 2; / a=2+2=4i = i + 32; / i=1+32=33c = c + 5; / c=10+5=15printf(“-

49、OTHER-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);b = a; / b=4运行结果：运行结果：-MAIN-i:1 a:0 b:-10 c:0-OTHER-i:33 a:4 b:0 c:15473.3.6变量的初始化变量的初始化int i = 1;main()static int a; register int b= -10; int c = 0;printf(“-MAIN-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);c = c + 8; / c=8other();printf(“-MAIN-n”);printf(“i

50、:%da:%db:%dc:%dn”,i,a,b,c);i = i + 10;other();other()static int a = 2; static int b; int c = 10;a = a + 2; / a=2+2=4i = i + 32; / i=1+32=33c = c + 5; / c=10+5=15printf(“-OTHER-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);b = a; / b=4运行结果：运行结果：-MAIN-i:1 a:0 b:-10 c:0-OTHER-i:33 a:4 b:0 c:15调用结束返回主函数调用结束返回

51、主函数main()483.3.6变量的初始化变量的初始化int i = 1;main()static int a; register int b= -10; int c = 0;printf(“-MAIN-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);c = c + 8; / c=8other();printf(“-MAIN-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);i = i + 10; other();other()static int a = 2; static int b; int c = 10;a = a + 2

52、; / a=2+2=4i = i + 32; / i=1+32=33c = c + 5; / c=10+5=15printf(“-OTHER-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);b = a; / b=4运行结果：运行结果：-MAIN-i:1 a:0 b:-10 c:0-OTHER-i:33 a:4 b:0 c:15-MAIN-i:33 a:0 b:-10 c:8493.3.6变量的初始化变量的初始化int i = 1;main()static int a; register int b= -10; int c = 0;printf(“-MAIN-n”

53、);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);c = c + 8; / c=8other();printf(“-MAIN-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);i = i + 10; / i=33+10=43other();other()static int a = 2; static int b; int c = 10;a = a + 2; / a=2+2=4i = i + 32; / i=1+32=33c = c + 5; / c=10+5=15printf(“-OTHER-n”);printf(“i:%da:%db:

54、%dc:%dn”,i,a,b,c);b = a; / b=4运行结果：运行结果：-MAIN-i:1 a:0 b:-10 c:0-OTHER-i:33 a:4 b:0 c:15-MAIN-i:33 a:0 b:-10 c:8再次调用函数再次调用函数other()503.3.6变量的初始化变量的初始化int i = 1;main()static int a; register int b= -10; int c = 0;printf(“-MAIN-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);c = c + 8; / c=8other();printf(“-MAI

55、N-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);i = i + 10; / i=33+10=43other();other()static int a = 2; static int b; int c = 10;a = a + 2; / a=4+2=6 i = i + 32; / i=1+32=33c = c + 5; / c=10+5=15printf(“-OTHER-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);b = a; / b=4运行结果：运行结果：-MAIN-i:1 a:0 b:-10 c:0-OTHER-i:3

56、3 a:4 b:0 c:15-MAIN-i:33 a:0 b:-10 c:8再次调用函数再次调用函数other()513.3.6变量的初始化变量的初始化int i = 1;main()static int a; register int b= -10; int c = 0;printf(“-MAIN-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);c = c + 8; / c=8other();printf(“-MAIN-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);i = i + 10; / i=33+10=43other()

57、;other()static int a = 2; static int b; int c = 10;a = a + 2; / a=4+2=6 i = i + 32; / i=43+32=75c = c + 5; / c=10+5=15printf(“-OTHER-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);b = a; / b=4运行结果：运行结果：-MAIN-i:1 a:0 b:-10 c:0-OTHER-i:33 a:4 b:0 c:15-MAIN-i:33 a:0 b:-10 c:8再次调用函数再次调用函数other()523.3.6变量的初始化变量

58、的初始化int i = 1;main()static int a; register int b= -10; int c = 0;printf(“-MAIN-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);c = c + 8; / c=8other();printf(“-MAIN-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);i = i + 10; / i=33+10=43other();other()static int a = 2; static int b; int c = 10;a = a + 2; / a=4+2=6

59、i = i + 32; / i=43+32=75c = c + 5; / c=10+5=15printf(“-OTHER-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);b = a; / b=4运行结果：运行结果：-MAIN-i:1 a:0 b:-10 c:0-OTHER-i:33 a:4 b:0 c:15-MAIN-i:33 a:0 b:-10 c:8再次调用函数再次调用函数other()53运行结果：运行结果：-MAIN-i:1 a:0 b:-10 c:0-OTHER-i:33 a:4 b:0 c:15-MAIN-i:33 a:0 b:-10 c:8-OTH

60、ER-i:75 a:6 b:4 c:15再次调用函数再次调用函数other()3.3.6变量的初始化变量的初始化int i = 1;main()static int a; register int b= -10; int c = 0;printf(“-MAIN-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);c = c + 8; / c=8other();printf(“-MAIN-n”);printf(“i:%da:%db:%dc:%dn”,i,a,b,c);i = i + 10; / i=33+10=43other();other()static int a = 2; static int b; in