C语言命名规则
第一个字符：是字母或者下划线，后面的：字母、下划线、数字。

数组特点

• 类型相同的元素的组成的集合
• 数组的空间连续
• 数组名是常量。

一维数组初始化

    //声明一个int类型的长度为10的数组
    //长度大于0，小于120
    int a[10];

    //长度可以用变量表示。但是n必须得有个确定的值，长度不能是变量的
    int n = 2;
    int b[n];

    //数组初始化，全部初始化//只有声明的时候，才能赋值一连串的值
    int c[5] = {1, 2, 3, 4, 5};
    //只初始化部分，其他后面的默认为0
    int d[5] = {1, 2, 3};
    //所有元素都初始化为0，原理就是上面的那条
    int e[100] = {0};
    //第一个元素的值是1，最后一个元素的值是3，其他值0补充
    int f[5] = {1, [4]=3};
    //如果不指定长度，那么必须初始化
    int m[]={1,2,3};

数组的访问

int main(void) {
    //声明一个int类型的长度为10的数组
    //长度大于0，小于120
    int a[5] = {1, 2, 3, 4, 5};
    //数组赋值
    a[2] = 44;
    //数组的输入，为输入的78
    scanf("%d", &a[0]);
    return 0;
}

image.png

int main(void) {
    //声明一个int类型的长度为10的数组
    //长度大于0，小于120
    int a[5] = {1, 2, 3, 4, 5};
    //数组赋值
    a[2] = 44;

    //数组的输入，为输入的78
    scanf("%d", &a[0]);
    //数组的输出
    printf("%d", a[1 + 1]);

    for (int i = 0; i < 5; ++i) {
        printf("%d", a[i]);
    }
    return 0;
}

一维数组地址

int main(void) {
    //声明一个int类型的长度为10的数组
    //长度大于0，小于120
    int a[5] = {1, 2, 3, 4, 5};

    printf("%d\n", sizeof(a));//20 一个int占4个字节，这里有5个int 就是4*5=20

    printf("数组的元素的值： %d，%d，%d，%d,%d\n", a[0], a[1], a[2], a[3], a[4]);
    printf("数组的元素的地址： %d，%d，%d，%d,%d\n", &a[0], &a[1], &a[2], &a[3], &a[4]);
    printf("数组的元素的地址偏移： %d，%d，%d，%d,%d\n", &a[0]+1, &a[1]+1, &a[2]+1, &a[3], &a[4]+1); //地址偏移就是地址+n
    printf("数组a的地址：%d，a偏移地址：%d\n", &a, &a + 1);

    //&a[0]+1是下一个元素&a[1]的地址，&a[1]比&a[0]大4，因为4个字节构成一个元素
    //&a的值和&a[0]的值一样
    //&a+1，是下一个数组的地址。也是本数组最后一个元素&a[4]的地址+1。
    return 0;
}

二维数组声明

• 二维数组的概念：元素是一维数组的一维数组是二维数组。
  （大白话是：一维数组，他的每个元素都是一个一维数组，这个就是二维数组。）
  元素是二维数组的一维数组是三维数组。
  元素是三维数组的一维数组是四维数组。
  元素是n维数组的一维数组是（n+1）维数组。
• 二维数组有两个[ ],n维数组有n个[ ]
• a[2][3]; 2表示最外面大数组的元素个数，3代表里面小数组的元素个数
• a[2][3]的数组的元素个数就是23=6，数组的大小就知道了：23*类型的字节数（sizeof()可以获取）

二维数组初始化

int main(void) {

    //二维数组的完全初始化
    int a[3][2] = {{2, 3},
                   {4, 5},
                   {6, 7}};

    //不完全初始化
    int b[3][2] = {{2, 3},
                   {4, 5}};
    //不完全初始化
    int c[3][2] = {{3},
                   {4, 5}};
    //不完全初始化
    int d[3][2] = {1, 2, 3, 4, 5};
      //可以这样初始化
    int e[][2] = {{2, 3},
                  {4, 5}};
    return 0;
}

结果

image.png

不完全初始化，就把后面的补充为0.
上面d，内存分配1，2 然后 3，4 最后5 ，最后没初始化的默认为0。

一维数组、二维数组，获取长度

    //二维数组的完全初始化
    int a[3][2] = {{2, 3},{4, 5},{6, 7}};

    int b[3] = {1, 2, 3};
    //获取一维数组b的长度=b的字节总数/b的一个元素所占的字节数
    int b_lenth = sizeof(b) / sizeof(b[0]);
    printf("b_lenth:%d", b_lenth);

    //获取二维数组a的行数 就是外面数组的长度
    int a_row = sizeof(a) / sizeof(a[0]);
    //获取二维数组a的列数 就是里面小数组的长度
    int a_column = sizeof(a[0]) / sizeof(a[0][0]);

二维数组的访问

int main(void) {

    //二维数组的完全初始化
    int a[3][2] = {{2, 3},
                   {4, 5},
                   {6, 7}};

    a[0][1];//意思：最外面的数组的第1个元素里面的第2个元素 这里的值是3
//先遍历行
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 2; ++j) {
            printf("%d\n", a[i][j]);
        }
    }
   //先遍历列
    for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < 3; ++j) {
            printf("%d\n", a[j][i]);
        }
    }


    return 0;
}

先遍历行运行结果

2
3
4
5
6
7

先遍历列运行结果

2
4
6
3
5
7

二维数组地址

image.png

• &a、&a[0]、&a[0][0]他们三个的地址值是一样的。
  *&a[1]==&a[1][0],&a[2]==&a[2][0]....
• &a+1 得到的是下一个数组的内存地址。
• &a[0]+1 得到的是&a[1][0]，&a[1][0]+1就是&a[2][0]
• &a[0][0]+1得到的是&a[0][1]，&a[0][1]+1得到的是&a[1][0]....

数组之间的赋值

错误的：

image.png
image.png

int main(void) {

    int a[5] = {1, 2, 3, 4, 5};
    int b[5];
    //循环赋值
    for (int i = 0; i < 5; ++i) {
        b[i] = a[i];
    }

    //将a里面的345放到c里面
    int c[3];
    for (int j = 0; j < 3; ++j) {
        c[j] = a[j + 2];
    }

    int d[5];
    //memcpy方法 第一个参数：需要copy到哪个对象，第二个参数是被copy的对象，第三个对象是字节个数。
    memcpy(d, a, sizeof(int) * 5);//完全copy，sizeof(int) * 5可以换成sizeof(a)

    //由上 d a是地址，&d=&d[0],&a=&a[0],所以上面可以写成：
    memcpy(&d[0], &a[0], sizeof(int) * 5); //其实就是从&a[0]地址开始复制，一共复制sizeof(int) * 5个字节到d中

    //所以下面就可以将a里面的345放到d中
    memcpy(&d[0], &a[2], sizeof(int) * 3);
    return 0;
}

二维复制

int main(void) {

    int a[3][2] = {1, 2, 3, 4, 5,6};
    int b[3][2];
    //memcpy方法 第一个参数：需要copy到哪个对象，第二个参数是被copy的对象，第三个对象是字节个数。
    memcpy(b, a, sizeof(int) * 6);//

    //由上 b、a是地址，&d=&a[0][0],&a=&b[0][0],所以上面可以写成：
    memcpy(&b[0][0], &a[0][0], sizeof(int) * 6); //其实就是从&a[0][0]地址开始复制，一共复制sizeof(int) * 6个字节到d中
    return 0;
}