C语言

一、数组
一维数组
    通过数组，可以一次性的分配多个同类型的连续存储区
    语法：
    类型 数组名字[元素个数]; 例：int arr[6]; arr占用内存6个整型大小的连续存储空间
    注意：
        通过下标可以区分数组的每个元素
            c语言数组下标从0开始，没有负数
            下标从0开始，一次加一
            arr[0] 表示数组中第一个元素
        数组的每个元素都可以独立的使用
        ***数组在使用时，要注意下标的范围，避免越界***
        每次程序运行，数组所占用的内存空间可能都不一样，这要看系统分配的内存位置
    数组初始化
        int arr[5] = {10, 20, 30, 40, 50}; // arr[0] = 10, arr[1] = 20, ......
        int arr[5] = {0};  // arr[0] = 0, arr[1] = 0,... 五个元素均为0
        int arr[5] = {};   // arr[0] = 0, arr[1] = 0,... 五个元素均为0
        int arr[5] = {1,2};  // arr[0] = 1, arr[1] = 2, arr[2] = 0,除了前两个有值，后面均为0
        int arr[] = {1,2,3,4,5}; //不定义元素个数，默认为后面花括号中元素的实际个数
        使用memset初始化
        int arr[5];
        memset(arr, 0, sizeof(arr)); // sizeof 获取arr数组的大小，这里是将5个元素都设为0，这里memset常用语结构体
        // 以下是接收键盘输入的7个学生的成绩，计算总成绩和平均分
        #include <stdio.h>
        int main(void)
        {
            float arr[7] = {0};
            float sum = 0;
            for (int i = 0; i < 7; i++) {
                printf("请输入第%d个同学的成绩：", i+1);
                scanf("%f", &arr[i]);
                sum += arr[i];
            }
            float average = sum / 7;
            printf("总成绩 = %g, 平均分 = %g\n", sum, average);
            return 0;
        }

二维数组
    二维数组中的每个元素都是一维数组，也就是说二维数组是由多个长度相同的一维数组构成的
    语法：
    数据类型 数组名[分组个数][每组的元素个数]
    int arr[2][2];  // 由两个长度为2的一维数组构成
    注意：
        二维数组中的每个存储区通过组下标(分组个数) 和 组内下标(一维数组的元素下标) 共同确定
        组下标表示具体的分组，从0开始，依次加一
        组内下标表示一组内的具体某个元素对应的下标，从0开始，依次加一
        arr[1][0]; 表示第二组中第一个元素
    二维数组初始化
        未初始化，如上int arr[2][2]; 每个里面的元素在未初始化时，都是随机数
        初始化方法：
          标准初始化：
          int arr[2][2] = {{10,20},{30,40}}; // arr[0][0] = 10 arr[0][1] = 20 arr[1][0] = 30 arr[1][1] = 40
                      初始化0：
              int arr[2][2] = {};
              int arr[2][2] = {{0}, {0}};
              int arr[2][2] = {{0}};
                      其他初始化：
              int arr[3][3] = {{1,2,3},{1,2},{1}}; // 当给数值不全，不全的元素默认设为0
              // arr[0][0~2] 1,2,3  arr[1][0~2] 1,2,0 arr[2][0~2] 1,0,0
              int arr[3][3] = {1,2,3,4,5,6,7,8,9}; // 如果每个每组没有花括号{}区分，name则按照顺序，每个分组依次读取单个组的元素个数作为本组元素
              // arr[0][0~2] 1,2,3  arr[1][0~2] 4,5,6 arr[2][0~2] 7,8,9
              memset方法：
                  int arr[2][2];
                  memset(arr,0,sizeof(arr)); // sizeof 获取arr数组的大小，这里是将二维数组的每个元素都设为0，这里memset常用语结构体
    例：
        #include <stdio.h>
        #include <string.h>
        int main(void)
        {
            // 定义二维数组
            int arr[4][5] = {{1,2,3,4,5}, {2,3,4,5,6}, {3,4,5,6,7}, {4,5,6,7,8,9}};
            memset(arr, 0, sizeof(arr));
            for (int i = 0; i < 4; i++) {
                for (int j = 0; j <5; j++) {
                    printf("%d ", arr[i][j]);
                }
                printf("\n");
            }
            return 0;
       }    
    
二、C语言-函数
C语言程序，由函数构成，函数是C代码的基本单位
  无论C语言程序有多少个函数，一定有且只有一个main函数
函数
    函数：是一堆语句的组合，具有独立性和通用性，可以将指定功能封装进函数里面。
    目的：将重复的操作或者公共的操作，代码只写一次，封装为函数，在需要该操作时，直接调用函数即可，无需再写一遍代码。
    比如五子棋，每次落子后，都要重新绘制棋盘，绘制棋盘的代码就可以封装成函数，当需要绘制棋盘的时候，就直接调用函数即可，不需要重复写绘制棋盘代码。
    语法：
    返回值类型 函数名(参数列表) {
        功能代码语句;
    }
        void 作为返回值和参数列表的话，则表示该函数无返回值，无参数列表。
    参数列表可以有多个，根据功能需求设计即可。
        传入的参数保证需函数功能代码需要的，不要添加无效参数。
        语法如下：
        返回值类型 函数名(参数类型1 参数名1, 参数类型2 参数名2, 参数类型3 参数名3,...)
        注意：
            一维数组作为参数，例如 fun(int *array, int len) 或者 fun(int array[], int len) 或者 fun(int array[5], int len)
            // 当数组作为参数时，一般会多加一个参数，表示数组的长度
            二维数组作为参数，例如fun(int arr[][10], int len) 二维数组的列数即第二个中括号的数值，必须指定,否则报错,len 作为行数，即第一个中括号的数值
       
                         例：
            // 该函数返回值为int类型，函数名为findmax，参数为 int指针类型(可表示数组 或者 int类型变量的地址) 和 int类型的数组长度，
        // 功能模块代码就是找数组中最大值，找出最大值后返回，返回值类型为int
        // 每当有需要找数组中最大值的功能，都随时可以调用该函数使用
        #include <stdio.h>
        // 函数的参数也成为形参，即形式上的参数，规定了函数需要的参数类型，当调用函数时，传入的参数会赋值给形参
        int findmax(int* arr, int len)
        {
            int max = arr[0];
            for (int i = 1; i < len; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            return max;
        }
        int main(void)
        {
            int arr[5] = {1,5,77,8,9};
            int arr1[6] = {1,4,7,9,22,5};
            // 这里findmax(arr, 5) 传入的是实参，相当于 将 main函数里的arr赋值给findmax函数形参中的arr，5赋值给findmax函数形参中的len
            printf("arr max = %d\n", findmax(arr, 5));
            printf("arr1 max = %d\n", findmax(arr1, 6));
            return 0;
        }
    函数的声明
        代码执行顺序：从main函数开始，到return结束
        代码编译顺序：gcc按照从上到下的顺序，逐行编译的
        当调用函数的语句在函数实现的前面时，编译就会报错，找不到函数,warning: implicit declaration of function
        这时可以先声明一下，函数实现可以放后面实现，相当于先给编译器打个招呼，说我有这个函数，后面会实现，调用的时候别给我报错
        例
          #include <stdio.h>
          //函数声明
          int mul(int, int);
          int main(void) {
              // 函数调用
              printf("3 * 5 = %d\n", add(3,5));
              return 0;
        }
        // 函数实现
        int add(int a, int b) {
             return a * b;
        }