C语言基础——数组

数组的基本概念

     一维数组

       定义变量格式 ： 数据类型 变量名称;

       定义数组：     数据类型 数组名[元素个数];
       1、数组只有定义才可以使用
       2、数组只有初始化了才可以被使用
       3、元素个数既可以使用常量也可以使用变量
     
       1、数组元素个数，在C99里规定是不可以使用变量的，LLVM、gcc编译器对数组进行扩展.
 
    //数组定义
    int cScores[3];
    //数组的初始化
    cScores[0] = 70;
    cScores[1] = 75;
    cScores[2] = 80;
    //  数组的多种初始化方式
    #include <stdio.h>

int main(int argc, const char * argv[]){
//先定义变量再进行初始化
    int num;
    num = 10;
    int num1 = 10;
    
    //  1、先定义数组在进行初始化
    int nums[3];
    nums[0] = 1;
    nums[1] = 2;
    nums[2] = 3;
    //2、定义数组的同时进行初始化
    //第一种格式
    int nums1[3] = {1,2,3};
    //第二种格式:后面的有几个元素那么数据的元素个数就是几
    int nums2[] = {1,2,3,4,5};
    int length = sizeof(nums2) / sizeof(int);
    // printf("%d\n",length);
    //第三种格式：按下标顺序依次赋值，没有显式赋值的默认赋值为0
    int nums3[20] = {1,3};
    length = sizeof(nums3) / sizeof(int);
    //    for (int i = 0; i < length; i++) {
    //        printf("%d\n",nums3[i]);
    //    }
    //第四种格式：指定元素初始化
    int nums4[10] = {[3] = 5,[6] = 10,[1] = 2 };
    length = sizeof(nums4) / sizeof(int);
    for (int i = 0; i < length; i++) {
        printf("nums4[%d] = %d\n",i,nums4[i]);
    }
    //定义的同时进行初始化，没有显式初始化的会被初始化为0
        //注意点 1、数组只有定义的时候才可以进行整体的初始化
        //    2、如果使用变量作用元素个数不可以定义的同时进行初始化
    return 0;
}

数组的存储细节

#include <stdio.h>
int main(int argc, const char * argv[]){
    char name[5] = {'a','p','p','l','e'};
    1、数组一块连续存储区域
    2、数组名是数组所占存储空间字节地址最小那个字节的地址
    3、下标就是相对于数组名称偏移量
    4、数组下标是从0开始
    
    char feel[5] = {'h','a','p','p','y'};
    //变量是从大字节开始分配，那么先定义的变量地址比后定义变量地址要大
//    printf("%p\n",name);
//    printf("%p\n",feel);
//    int length = sizeof(name);
//    for (int i = 0; i < length; i++) {
//        printf("name[%d] = %p \n",i,&name[i]);
//    }
    
    1、数组下标越界(错误的),非常危险
    feel[5] = 'z';
    printf("%c\n",name[0]);
    //数组下标越界害处
//        1、约会约错了对象(导致程序逻辑错误)
//        2、导致程序崩溃
//    printf("%c",name[-2]);
    return 0;
}

函数与数组

基本数据类型作为参数传递是值传递
数组作为函数参数传递是地址传递

数组作为函数参数传递的时候，转换为指针

二维数组

 二维数组基本概念

      二维数组的多种初始化方式
      数据类型 数组名称[元素个数]
      数据类型 数组名称[一维数组个数][一维数组的元素个数];
     只要是数组就是一块连续的存储区域
     注意点：二维数组如果没有初始化里面存放都是垃圾值
    //1、先定义再进行初始化
    int nums[2][3];
    nums[0][0] = 2;
    nums[0][1] = 3;
    //2、定义的同时进行初始化
//  只要是定义的同时进行初始化，那么所有没有显式初始化的值都会被初始化为0
//  1、第一种方式
    int nums1[2][3] = {{1,2,3},{4,5,6}};
//  2、第二种方式:不指定一维数组个数
    int nums2[][3] = {{1,2,3},{4,5,6}};
//  3、第三种方式
//    int nums3[][3] = {1,2,3,4,5,6};
    int nums3[][3] = {1,2,3,4,5};
//  4、第四种
    int nums4[2][3] = {1,2,3,4,5,6};
//  5、部分初始化
//    5.1
    int nums5[3][3] = {1,2};
    int nums6[3][3] = {{1},{2},{3}};
    //计算二维数组中有多少一维数组
//    int len = sizeof(nums6) / sizeof(nums6[0]);
//    printArray(nums6, len);

总结

   数组：用来存放一组相同数据类型的数据的，（容器）
   数组定义格式：数据类型 数组名称[元素个数]
   数组的特点：
        1、只能存放一种数据类型的多个数据
        2、数组是连续的存储空间
        3、数组的每一个元素都有下标的，并且下标是从0开始的
        4、数组名就是一个地址，是这个数组所在存储空间最小那个字节编号
        
   数组的多种定义方式：
        1、先定义在进行初始化
           1.1使用常量作为元素个数
              int nums[10];
           1.2变量作为元素个数
              int count = 10;
              int nums[count];
           注意点：
            1、没有初始的数组元素里面都是垃圾值
            2、不可以整体赋值
               num = {1,2,3} 错误
               num[10] = {1,2,3} 错误
        2、定义的同时进行初始化
           1、第一种方式，指定元素个数的同时对所有元素进行初始化
           int nums[3] = {1,2,4};
           2、第二种方式，不指定元素个数，给数组进行初始化
           int nums[] = {1,2,3};
           3、第三种方式 指定元素个数，对数组进行部分初始化
          int nums[10] = {1,2};
            4、第四种方式 指定元素个数，对指定元素进行初始化
            int nums[10] = {[1] = 3,[4]=5}
          特点：
              1、所有没有显式初始化的元素会被自动初始化为0
          注意点：
             变量作为元素个数不可以使用这种方式
    数组与函数
       1、 数组作为函数参数传递是地址传递
       2、 数组作为函数参数，数组自动被转换为指针类型

    二维数组：元素是一维数组的数组
    格式：    数据类型 数组名称[一维数组的个数][一维数组的元素个数]
    int nums[2][3] = {{1,2,3},{4,5,6}};
    二维数组的遍历
        1、外层循环控制第一个角标
        2、内层循环控制第二个角标