《C语言宝典》学习笔记(五)：变量

1       变量

局部变量用关键字auto进行说明, 当auto省略时, 所有的非全程变量都被认为是局部变量, 所以auto实际上从来不用。

全程变量只要满足在使用它以前和函数以外这两个条件, 可在程序的任何位置进行说明, 习惯上通常在程序的主函数前说明。

1.1    变量存储类型

 Turbo C2.0支持四种变量存储类型。说明符如下:
     auto      static    extern    register
下面分别来介绍。
    一、auto
    auto称为自动变量, 已在前面作了介绍, 这里不再重复。
    二、static
    static称为静态变量。根据变量的类型可以分为静态局部变量和静态全程变量。
    1. 静态局部变量
    它与局部变量的区别在于: 在函数退出时, 这个变量始终存在, 但不能被其它函数使用, 当再次进入该函数时, 将保存上次的结果。其它与局部变量一样。
    2. 静态全程变量
    Turbo C2.0允许将大型程序分成若干独立模块文件分别编译, 然后将所有模块的目标文件连接在一起, 从而提高编译速度, 同时也便于软件的管理和维护。静态全程变量就是指只在定义它的源文件中可见而在其它源文件中不可见的变量。它与全程变量的区别是: 全程变量可以再说明为外部变量(extern), 被其它源文件使用,而静态全程变量却不能再被说明为外部的, 即只能被所在的源文件使用。

三、extern
    extern称为外部变量。为了使变量除了在定义它的源文件中可以使用外, 还要被其它文件使用。因此,必须将全程变量通知每一个程序模块文件,此时可用extern来说明。
    例如:
        文件1为file1.c                  文件2为file2.c
    int i, j;/*定义全程变量*/        extern int i, j;/*说明将i, j从
                                                     文件1中复制过来*/
    char c;                          extern char c; /*将c复制过来*/
    void func1(int k);               func2()        /*用户定义函数*/
                                     {
    main()                              static float k;/*定义静态变量*/
    {                                   i=j*5/100;
          func1(20);/*调用函数*/        k=i/1.5;
          func2();                           .
          .                                  .
          .                                  .
          .                            }
     }
     func1(int k) /*用户定义函数*/
     {
          j=k*100;
     }

    对于以上两个文件file1.c和file2.c, 用Turbo C2.0的集成开发环境进行编译连接时, 首先应建立一个.prj的文件。例如file.prj, 该文件内容如下:
     file1.c
     file2.c
    然后将file.prj的文件名写入主菜单Project中的Project Name项中。 再用F9编译连接, 就可产生一个文件名为fioe.exe的可执行文件。
    外部变量和FORTRAN语言中的COMMOM定义的公共变量一样。

四、register

register称为寄存器变量。它只能用于整型和字符型变量。定义符register说明的变量被Turbo C2.0存储在CPU的寄存器中,  而不是象普通的变量那样存储在内存中, 这样可以提高运算速度。但是Turbo C2.0只允许同时定义两个寄存器变量,一旦超过两个, 编译程序会自动地将超过限制数目的寄存器变量当作非寄存器变量来处理。因此, 寄存器变量常用在同一变量名频繁出现的地方。

另外, 寄存器变量只适用于局部变量和函数的形式参数, 它属于auto型变量,因此, 不能用作全程变量。定义一个整型寄存器变量可写成:
      register int a;

1.2    数组变量

数组由一段连续的存贮地址构成, 最低的地址对应于第一个数组元素, 最高的地址对应最后一个数组元素。

大多数字符串用一维数组表示。数组元素的多少表示字符串长度,数组名表示字符串中第一个字符的地址,例如在语句char  str[ 8] 说明的数组中存入"hello"字符串后, str表示第一个字母"h"所在的内存单元地址。str[0] 存放的是字母"h"的ASCII码值, 以此类推, str[4]存入的是字母"o"的ASCII码值, str[5]则应存放字符串终止符'/0'。

Turbo C2.0对数组不作边界检查。例如用下面语句说明两个数组
    char str1[5], str2[6];
    当赋给str1一个字符串"ABCDEFG"时, 只有"ABCDE"被赋给, "E" 将会自动的赋
给str2, 这点应特别注意。  ？？

 

多维数组的一般说明格式是:
       类型  数组名[第n维长度][第n-1维长度]......[第1维长度];
    这种说明方式与BASIC、FORTRAN等语言中多维数组的说明不一样。

数组占用的内存空间(即字节数)的计算式为:
        字节数=第1维长度*第2维长度*...*第n维长度*该数组数据类型占用的字节数

1.3    变量的初始化和赋值

一、变量的初始化

变量的初始化是指变量在被说明的同时赋给一个初值。Turbo C2.0中外部变量和静态全程变量在程序开始处被初始化, 局部变量包括静态局部变量是在进入定义它们的函数或复合语句时才作初始化。所有全程变量在没有明确的初始化时将被自动清零, 而局部变量和寄存器变量在未赋值前其值是不确定的。
    对于外部变量和静态变量, 初值必须是常数表达式, 而自动变量和寄存器变量可以是任意的表达式, 这个表达式可以包括常数和前面说明过的变量和函数。
    1. 单个变量的初始化
    例如:
     float f0, f1=0.2;/*定义全程变量, 在初始化时f0被清零, f1被赋0.2*/
     main()
     {
          static int i=10, j; /*定义静态局部变量, 初始化时i被赋10, j不确
                              定*/
          int k=i*5;          /*定义局部变量, 初始化时k被赋10*5=50*/
          char c='y';         /*定义字符型指什变量并初始化*/
          .
          .
          .
     }

    2. 数组变量的初始化
    例如:
     main()
     {
          int p[2][3]={{2, -9, 0}, {8, 2, -5}};  /*定义数组p并初始化/*
          int m[2][4]={{27, -5, 19, 3}, {1, 8, -14, -2}};/*定义数组m并初
                                                         始化*/
          char *f[]={'A', 'B', 'C'};         /*定义数组f并初始化*/
          .
          .
          .
     }
    从上例可以看出: Turbo C2.0中数组进行初始化有下述规则:
    (1) 数组的每一行初始化赋值用"{}"并用","分开, 总的再加一对"{}"括起来,
最后以";"表示结束。
    (2) 多维数组的存储是按最右维数的变量变化最快的原则。
    (3) 多维数组存储是连续的, 因此可以用一维数组初始化的办法来初始化多维
数组。
    例如:
     int x[2][3]={1, 2, 3, 4, 5, 6};/*用一维数组来初始化二维数组*/
    (4) 对数组初始化时, 如果初值表中的数据个数比数组元素少, 则不足的数组
元素用0来填补。
    (5) 对指针型变量数组可以不规定维数, 在初始化赋值时, 数组维数从0 开始
被连续赋值。
    例如:
     char *f[]={'a', 'b', 'c'};
    初始化时将会给3个字符指针赋值, 即: *f[0]='a', *f[1]='b', *f[2]='c'。

二、变量的赋值

Turbo C2.0中允许给多个变量赋同一值时可用连等的方式。
    例如:
     main()
     {
          int a, b, c;
          a=b=c=0;       /*同时给a,b,c赋值*/
          .
          .
          .
     }

(3) 指针型变量
    例如:
     main()
     {
          int *i;
          char *str;
          *i=100;
          str="Good";
          .
          .
          .
     }
    *i表示i是一个指向整型数的指针, 即*i是一个整型变量, i是一个指向该整型变量的地址。*str表示str是一个字符型指针, 即保留某个字符地址。在初始化时, str没有什么特殊的值, 而在执行str="Good"时, 编译器先在目标文件的某处保留一个空间存放"Good/0"的字符串, 然后把这个字符串的第一个字母"G"的地址赋给str, 其中字符串结尾符"/0"是编译程序自动加上的。
    对于指针变量的使用要特别注意。上例中两个指针在说明前没有初始化, 因此这两指针为随机地址, 在小存储模式下使用将会有破坏机器的危险。正确的使用办法如下:
    例如:
     main()
     {
          int *i;
          char *str;
          i=(int*)malloc(sizeof(int));
          i=420;
          str=(char*)malloc(20);
          str="Good, Answer!";
          .
          .
          .
     }
    上例中, 函数(int*)malloc(sizeof(int))表示分配连续的sizeof(int)=2个字节的整型数存储空间并返回其首地址。同样(char*)malloc(20)表示分配连续20 个字节的字符存储空间并返回首地址(有关该函数以后再详述)。由动态内存分配函数malloc()分配了内存空间后, 这部分内存将专供指针变量使用。

 如果要使i指向三个整型数, 则用下述方法。
    例如:
     #include<alloc.h>
     main()
     {
          int *a;
          a=(int*)malloc(3*sizeof(int));
          *a=1234;
          *(a+1)=4567;
          *(a+2)=234;
          .
          .
          .
     }
    *i=1234表示把1234存放到i指向的地址中去, 但对于*(i+1)=4567,  如果认为将4567存放到i指向的下一个字节中就错了。Turbo C2.0中只要说明i为整型指针,

则    (i+1)  等价于   i+1*sizeof(int)

同样  (i+2)  等价于   i+2*sizeof(int)

 (2)字符串数组的赋值

  例如:
      main()
     {
          char s[30];
          strcpy(s, "Good News!");  /*给数组赋字符串*/
          .
          .
          .
     }
    上面程序在编译时, 遇到char s[30]这条语句时, 编译程序会在内存的某处留出连续30个字节的区域, 并将第一个字节的地址赋给s。当遇到strcpy( strcpy 为Turbo C2.0的函数)时, 首先在目标文件的某处建立一个"Good News!/0" 的字符串。其中/0表示字符串终止, 终止符是编译时自动加上的, 然后一个字符一个字符地复制到s所指的内存区域。因此定义字符串数组时,  其元素个数至少应该比字符串的长度多1。
    注意:
    1. 字符串数组不能用"="直接赋值, 即s="Good News!"是不合法的。所以应分清字符串数组和字符串指针的不同赋值方法。
    2. 对于长字符串, Turbo C2.0允许使用下述方法:
    例如:
     main()
     {
          char s[100];
          strcpy(s, "The writer would like to thank you for"
                    "your interest in his book. He hopes you"
                    "can get some helps from the book.");
          .
          .
          .
     }

三、数组与指针

数组与指针有密切的联系。数组名本身就是该数组的指针, 反过来, 也可以把指针看成一个数组, 数组名和指针实质上都是地址, 但是指针是变量, 可以作运算。而数组名是常量, 不能进行运算。
    例如:
     main()
     {
          char s[30], *p; /*定义字符型数组和指针变量*/
          p=s;            /*指针p指向数组s的第一个元素s[0]的地址*/
          .
          .
          .
          *(p+8);         /*指针p指向数组s的第9个元素s[8]的地址*/
          .
          .
          .
     }
    由上例可以看出数组和指针有如下关系:
    (p+i)=&(s[i])
    *(p+i)=s[i]
    因此, 利用上述表达式可以对数组和指针进行互换。两者的区别仅在于: 数组s是程序自动为它分配了所需的存储空间; 而指针p则是利用动态分想函数为它分配存储空间或赋给它一个已分配的空间地址。