黑马程序员－ios学习笔记 c语言 数组

1. ------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

2. 
   

     一、数组的概念

           用来存放若干个类型相同的有序的数据的结构，也是一种构造类型。

      1、数组的特点：若干个  、类型相同  、有序（地址有序）。

      2、数组的名词： 数组名：  标识这个数组的名称

                    数组元素：数组中的每一个存储空间

                    数组长度：存放元素的个数

    二、数组的分类

       1、按存储内容分：   数值型数组 ：  存数值         —> int

                        字符型数组 ：  存字符         —> char

                        指针数组   ：    存指针         —> *p

                        结构数组   ：    存放结构体  —> struct

       2、按照维数分：一维数组、二维数组、多维数组

   三、一维数组

    1、一维数组的定义：数组存放的每一个元素都是一个数值

         格式： 数据类型  数组名[数组的长度];

        例：int a[10];   //定义了一个int类型数组，存放10个int数，数组名是a,数组长度为10

           float f1[5]; //定义了一个float类型的数组，存放5个float数，数组名 f1,数组长度为5

           char ch[3];  //定义了一个char类型的数组，存放3个字符型的数据，数组名 ch,数组长度为3

    2、一维数组的定义注意事项

         1） 数据类型修饰的是数据每个元素的类型。例： int a[5]; 每个元素都是int类型。

         2) ［数组的长度］中括号内可是常量、字符常量、常量表达式、宏

                例：int a[8];      //  长度 8

                   int a[2+3];  //等同于 int a[5]   长度 5

                   int a['A'];    //等同于 int a[65]   长度 65

                  #define M 3   //此处是一个宏定义

                   int a[M];         //等同于 int a[3];

                   int a[M+3];     //等同于  int a[6];

                   注：int len=4;    

                      int a[len]; //这句话在C99标准中是不可以的，但是 在xcode中这是可以的            

         3)   数组名不能和变量名同名。例： int arr; int arr[5]; //错误的

         4）数组名严格遵守标识符的命名原则和规范。例：char userName[10];

         5)  可以混合定义数组和变量。例：   int a,b,c,a1[4],a2[4];

    3、一维数组初始化的方法:

       1）定义的同时进行初始化

          （1）定义的同时，完全初始化

              格式：数据类型 数组名[数组长度]={值1,值2,.....};

                        值的个数 == 数组的长度

              例： int a[5] = {1,2,3,4,5};

              注：对于定义的同时完全初始化的数组来说，定义数组的时候，可以

              省略数组长度。

              例： int a1[] = {1,2,34,5};  //数组根据初始化的时候值的个数来确定数组的长度

          （2）定义的同时，部分初始化

              （1）值的个数小于数组的长度时

                 例：  int a2[5]={1};        // 部分初始化，此时把1给数组的第一个元素

                (2)指定元素的初始化

                    数组的下标：下标用来访问数组的下标的范围：

                    例：   int a[n];  下标从 0 ~ n-1

                              a[0]  ~   a[n-1]  可以访问数组元素

                              int a3[5]={[2]=10};  //指定下标为2的元素的值是 10 

       2）先定义后初始化

            int a3[5];   //给定义一个int类型数组

            a3[0] = 1;   //给数组第一个元素赋值

            a3[1] = 2;   //给数组第二个元素赋值

            a3[2] = 3;   //给数组第三个元素赋值

            a3[3] = 4;   //给数组第四个元素赋值

            a3[4] = 5;   //给数组第五个元素赋值

            a3[5] = 6;   //给数组第六个元素赋值

          注意点：以下的写法是错误的

                     int len = 4; 

                     int a5[len]={1,2,3,4};

    4、一维数组的引用：就是获取数组中存储的内容   

         引用数组元素的方法： 

            通过下标可以获取数组中的每一个元素的值

           例：   int a[n];    //长度为n，可以存储n个int类型的数    

                 下标： 0  ~  n-1       

                 a[0] 是第一个元素

                 a[n-1] 是最后一个元素

                           0 1 2 3 4

                 int a[5]={1,2,3,4,5}; 

                     printf("%d\n",a[0]);   //1  

                     printf("%d\n",a[3]);   //4

   注：1） 如果一个数组进行了部分初始化，那么这个数组没有初始化的部分，自动初始化为0；

      2)   如果一个数组定义后，不进行初始化，此时数组的每一个元素值是垃圾值。

   例：数组的遍历

   #include <stdio.h>
   #define M 8   //定义一个宏M
   int main(int argc, const char * argv[]) {
       int a[M]={9,33,56,78,2,4,8,59};  //定义一个int型一维数组
       for (int i=0; i<M; i++) {        //用for循环对数组a进行遍历
           printf("a[%d]=%d\t",i,a[i]); //输出数组a每个元素的值
       }printf("\n\n");
       int b[2][3]={3,4,6,8,66,34};     //定义一个int型二维数组
       for (int m=0; m<2; m++) {        //用双重for循环对数组b进行遍历
           for (int n=0; n<3; n++) {
               printf("b[%d][%d]=%d\t",m,n,b[m][n]); //输出数组b每个元素的值
           }
       }
           return 0;
   }

   四、数组的存储方式： 

           数组存储的是相同类型的数据的集合，数组由多个元素组成，每个元素都在内存中占用存储空间。

       1)数组的存储空间大小＝每个元素占用的存储空间之和。

              sizeof(数组名);  //计算出数组在内存中占用的字节数

       2)数组在内存中占用的一片连续的内存空间

       3)数组的元素在内存中是依次存储的，先存储a[0]

          例：  int a[3];    //定义一个整形数组，数组名a 能存放3个元素（int） 

               sizeof(a);   //12   // 4 * 3 = 12

   五、数组长度的计算方法 

         注：数组在内存中占用的总得字节数 和 数组的长度是两码事

         数组长度＝数组占用的总字节数 / 每个元素占用的字节数

   例：数组长度的计算

   #include <stdio.h>
   
   int main(int argc, const char * argv[]) {
       int a[3]={1,3,5};                //定义一个整型数组
       char str[4]={'a','b','c'};       //定义一个字符型数组
       float f1[5];                     //定义一个单精度数组
       long l1[6];                      //定义一个长整型数组
       int len=0,len1=0,len2=0,len3=0;  //定义4个整型变量，初始化为0
       len=sizeof(a)/sizeof(int);       //计算数组a的长度
       len1=sizeof(f1)/sizeof(float);   //<span style="font-family: Monaco, Consolas, 'Lucida Console', 'Courier New', serif;">计算数组f1的长度</span>
       len2=sizeof(str)/sizeof(char);   //<span style="font-family: Monaco, Consolas, 'Lucida Console', 'Courier New', serif;">计算数组str的长度</span>
       len3=sizeof(l1)/sizeof(long);    //<span style="font-family: Monaco, Consolas, 'Lucida Console', 'Courier New', serif;">计算数组l1的长度</span>
       printf("len=%d,len1=%d,len2=%d,len3=%d\n",len,len1,len2,len3);//输出各数组的长度值
   
           return 0;
   }

   六、数组的地址

        1）数组的地址 

             数组的地址 == 数组的首地址 

             数组的首地址，数组的第一个元素（a[0]）的地址 

             数组的第一元素的地址 == 数组的第一个元素的第一个字节的地址

             例：int a[10];  //a数组的地址：&a[0]== a;数组名a保存的就是数组的地址 

        2）数组元素的地址 

           &a[0]   //a[0]的地址

           &a[1]   //a[1]的地址

           &a[2]   //a[2]的地址

       注意: 数组名 a 它是一个常量，存放的就是我们数组的首地址（&a[0]）

   int main(int argc, const char * argv[]) {
       int a[8]={9,33,56,78,2,4,8,59};  //定义一个int型一维数组
       int b[2][3]={3,4,6,8,66,34};     //定义一个int型二维数组
       printf("\na=%p,a[0]=%p\nb=%p,b[0][0]=%p",a,&a[0],b,&b[0][0]); //输出数组a的地址，a第一个元素的地址；数组b的地址，b第一个元素的地址
       return 0;
   }

   七、数组的越界： 数组的下标范围：0开始 到 长度-1 

                 访问的元素的下标超出正常的下标范围，就是越界。

   
   

         

   1. ------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------