wdg_009.txt

c编程宝典,详细介绍有关c的资料

    (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'。 

    3. 指针型变量的初始化 
    例如: 
     main() 
     { 
          int *i=7899;        /*定义整型数指针变量并初始化*/ 
          float *f=3.1415926; /*定义浮点数指针变量并初始化*/ 
          char *s="Good";     /*定义字符型指针变量并初始化*/ 
          . 
          . 
          . 
     } 

    二、变量的赋值 
    变量赋值是给已说明的变量赋给一个特定值。 
    1. 单个变量的赋值 
    (1) 整型变量和浮点变量 
    这两种变量采用下列格式赋值 
          变量名=表达式; 
    例如: 
     main() 
     { 
          int a, m;      /*定义局部整型变量a, m*/ 
          float n;       /*定义局部浮点变量f*/ 
          a=100, m=20;   /*给变量赋值*/ 
          n=a*m*0.1; 
          . 
          . 
          . 
     } 

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

    (2)  字符型变量 
    字符型变量可以用三种方法赋值。 
    例如: 
     main() 
     { 
          char a0, a1, a2;    /*定义局部字符型变量a0, a1, a2*/ 
          a0='b';             /*将字母b赋给a0*/ 
          a1=50;              /*将数字2(十进制ASCII值为50赋给a1*/ 
          a2='\x0d';          /*将回车符赋给a2*/ 
          . 
          . 
          . 
     } 

    (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. 数组变量的赋值 
    (1) 整型数组和浮点数组的赋值 
    例如: 
     main() 
     { 
          int m[2][2]; 
          float n[3]; 
          m[0][0]=0, m[0][1]=17, m[1][0]=21;/*数组元素赋值*/ 
          n[0]=109.5, n[1]=-8.29, n[2]=0.7; 
          . 
          . 
          . 
     } 

    (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."); 
          . 
          . 
          . 
     } 

    (3)指针数组赋值 
    例如: 
     main() 
     { 
          char *f[2]; 
          int *a[2]; 
          f[0]="thank you";   /*给字符型数组指针变量赋值*/ 
          f[1]="Good Morning"; 
          *a[0]=1, *a[1]=-11; /*给整型数数组指针变量赋值*/ 
          . 
          . 
          . 
     } 

    三、数组与指针 
    数组与指针有密切的联系。数组名本身就是该数组的指针, 反过来, 也可以把 
指针看成一个数组, 数组名和指针实质上都是地址, 但是指针是变量, 可以作运算。 
而数组名是常量, 不能进行运算。 
    例如: 
     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则是利用动态分想函数为它分配 
存储空间或赋给它一个已分配的空间地址。