计算机_C语言_数组和指针

volcanol

计算机_C语言_数组和指针_笔记

一、数组
1、定义： 数组是若干同类型变量的聚合，允许通过统一的名字引用各个变量。数组通过下标引用特定的元素。
    语法格式：
         type  变量名标识符[数组长度]；
   exp：
        int array[100];  //定义一个长度为100的整型数组
        double  balance[100]; //定义一个长度为100的双精度的浮点类型数组

2、数组的引用
   数组的下标从0开始， 下标的最大值为：数组长度-1；
   exp：
        int array[10];
   那么要引用数组所有元素就是为：
     array[0]、array[1]........array[9];
3、注意点：
      1、在定义数组的时候；如果没有初始化，那么数组长度不能省。
      2、在定义数组的时候， 规定数组长度不能是变量，就是说
          type  变量名标识符[数组长度]； 中的“数组长度”不能是变量
      3、在引用数组元素的时候，其下标可以是常量、变量和表达式。
         Exp：
             int  array[10];
             int  i;
             array[1]=10;

             i=3;
             array[i]=189;  //这里就是说 array[3]=189
            
             array[i%2]=100;  //这里因为i%2=3%2=1， 就是说array[1]=100;
      4、在引用数组元素的时候一定要注意不能越界，就是说引用数组的时候小标不能小于0，并且
         下标的值不能超过数组长度减1；
          Exp：
                int array[10];
         
                array[-1]=199 ; //这里就错误，出现了下标越界，并且是下越界
               
                array[16]=39;  //这里也错误，出现了下标越界，并且是上越界
     5、 在C语言里规定， 数组的名字是一个常量，并且表示数组的首地址， 这一点在
         数组和指针的运算过程中非常重要，经常会进行数组的首地址赋值给指针变量。
     6、数组的元素在内存中是按照顺序来排列的，因此在引用的时候可以利用这一特征。
4、 一维数组的初始化
    和定义非数组变量一样，可以在数组定义的时候初始化。通常初始化数组的方法如下所示：
    Exp：
       int a[10]={1,2,3,4,5,6,7,8,9,10};
    如上所示： 使用花括号括起来的一系列数值来初始化数组，数值之间用逗号隔开，在数值和
    逗号之间允许有空格符，或空白字符。
    注解： 在ANSI C以前的编译器， 只有具有静态属性的数组才能初始化；即必须使用static
    关键字。
    1、 如果为字符型数组还可以使用字符串常量给数组初始化。
        Exp：
            char array[15]="hello world!";
        这样初始化后：   array[0]='h';
                        array[1]='e';
                        array[2]='l';
                        array[3]='l';
                        array[4]='o';
                        array[5]=' ';
                        array[6]='w';
                        array[7]='o';
                        array[8]='r';
                        array[9]='l'
                        array[10]='d';
                        array[11]='\0';
                        array[12]=array[13]=array[14]='\0';
        这里要注意： array[11]='\0'是与后面的array[12]='\0'是不一样的， array[11]='\0'
        是字符串的结束字符为'\0'. 字符串"hello world"一共占有12个字节的内存空间， 因此需要
        12个数组元素来处理，这样a[11]就存储了字符串最后一个字符'\0'.
        而array[12]=0 是因为当初始化的时候，如果用来初始化的值个数小于数组的长度，则缺少的
        部分按照相应类型的缺省值的初始化数组剩下的元素。通常初始化为零值。
     2、 二维数组的初始化
        二维数组的初始化可以利用递归的思想来理解。 只要递归一下一维数组的初始化方法，就可以
        理解二维数组的初识化。
     3、如果进行数组的初始化，那么数组的长度可以省略， 编译器会根据初始化值的个数定义数组的长度。
        Exp：
             char array[]="hello world";
        这样数组array的长度就是字符串"hello world"的长度。
        当二维数组不能省略最后一维数组的长度。
        Exp：
             char array[][3]={{"ab"},{"cd"}};  //通常不建议这样初始化，因为增加了理解的难度。
     4、数组也能像其他变量一样可以用修饰符来修饰
        比方说： const  static
        如果我们想定义一个不能被修改的数组，那么就可以如下定义：
        Exp：
             const char array[]="hello world";
        这样就不能再在程序运行的过程当中改变array字符型数组的元素的值了。  
5、指针和数组
   C中规定数组的名字是一个指针型的常量， 并且这个指针常量代表的是数组的地址，
   同时也代表的是数组的首元素的地址。
   Exp：
        char array[10];
    那么：
        array==&array[0];  这个表达式的返回值是  TRUE。
    这里说明： array和 &array[0]都代表首元素的内存地址。并且两者都是常量，因为在程序运行的
    过程中他们保持不变。
    1、对于数组和指针有几点要注意的：
       array+2 == &array[2];   //相同的地址
       *(array+2)==array[2];   //相同的值
    理解这种关系对于用指针处理数组非常有帮助。
    2、对于引用array[index]时可以这样理解： 其实是*（array+index）； 即首先在计算机的内存中寻找
       到array这个地址，然后再向后移动index个单位，再取出里面存储的内容。
    3、 理解下面这个关系：
        int  array[10];
        int  index;
        那么：  array表示数组首元素的地址，array+index是元素array[index]的地址，*(array+index)是这个元素
        的值，与array[index]等价。
        这就是说：
                array==&array[0];
                array+2==&array[2];  // 这里理解+2 是由首元素向后移动连个元素， array[2]也是从首元素往后移动
                                     //两个元素。
                *(array+2)==array[2];  //这里由 *和 []两个运算符的作用和上面的等式决定。

6、 指针、数组和函数
   在C语言中，只要可以定义的数据类型均可以作为函数的参数来进行传递， 同样数组也一样可以当做函数参数来传递。
   通常有三种方式来传递数组参数：
    1、定义长度确定的数组形式参数
       Exp：
             #include <stdio.h>
             int  max(int x[3])
               {
                    return  x[0]>=x[1]? (x[0]>=x[2]？x[0]:x[2]) : (x[1]>=x[2]?x[1]:x[2]);
               }
             int main(int argc,char *argv[])
               {
                   int array[3]，
                       themax;
                   for(int i=0;i<3;i++)
                      {
                          printf("Please input array[%d]:",i);
                          scanf("%d",array+i);
                       }
                  themax=max(array); //注意数组参数在实参传递的格式。 也可以： themax=max(&array[0]);
                  printf("The max is: %d", themax);
                  retrun 1;
                }
         这种定义方法有一定的局限性： 就是传递的实际参数的长度不能超过数组形式参数的长度。 ？
     2、定义长度不定的数组形式参数
        Exp：
             #include <stdio.h>
             int  max(int x[])
               {
                    return  x[0]>=x[1]? (x[0]>=x[2]？x[0]:x[2]) : (x[1]>=x[2]?x[1]:x[2]);
               }
             int main(int argc,char *argv[])
               {
                   int array[3]，
                       themax;
                   for(int i=0;i<3;i++)
                      {
                          printf("Please input array[%d]:",i);
                          scanf("%d",array+i);
                       }
                  themax=max(array); //注意数组参数在实参传递的格式。 也可以： themax=max(&array[0]);
                  printf("The max is: %d", themax);
                  retrun 1;
                }
     3、定义指针来接收数组元素
        Exp：
             #include <stdio.h>
             int  max(int *x)
               {
                    return  *x>=*（x+1）? (*x>=*(x+2)？*x:*(x+2)) : (*(x+1)>=*(x+2)?*(x+1):*(x+2) );
               }
             int main(int argc,char *argv[])
               {
                   int array[3]，
                       themax;
                   for(int i=0;i<3;i++)
                      {
                          printf("Please input array[%d]:",i);
                          scanf("%d",array+i);
                       }
                  themax=max(array); //注意数组参数在实参传递的格式。 也可以： themax=max(&array[0]);
                  printf("The max is: %d", themax);
                  retrun 1;
                }

夜月幽梦

太震撼了  顶你

qiushuo

学习了，顶下

lin490094640

嗯学习学习。。。