C语言基础教程之数组

最新推荐文章于 2023-05-20 05:53:21 发布

古极

最新推荐文章于 2023-05-20 05:53:21 发布

阅读量1.9k

点赞数

分类专栏： C 文章标签： C C语言 C语言教程

本文链接：https://blog.csdn.net/SparkLee2013/article/details/85337985

版权

C 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

C语言基础教程目录：https://blog.csdn.net/SparkLee2013/article/details/85229406

1、数组是什么

在程序设计中，为了方便处理数据，将具有相同类型的若干变量按有序形式组织起来的一种结构，称之为数组。

数组就是在内存中连续的相同类型的变量空间。同一数组所有成员都是相同的数据类型，同时所有的成员在内存中的地址是连续的。

2、数组的定义和使用

一维数组定义：数据类型数组名[元素个数] = {初始化值} | int arr[10] = {0}

二维数组定义：数据类型数组名[行数][列数] = {初始化值} | int arr[2][3] = {0}

三维数组定义：数据类型数组名[层数][行数][列数] = {初始化值} | int arr[2][5][10] = {0}

四维数组定义：数据类型数组名[第一级层数][第二级层数][行数][列数] = {初始化值} | int arr[2][10][3][2] = {0}

1）一维数组的定义和使用：

#include <stdio.h>

void main() {
    // 一、先定义后赋值
    int arr[2];
    arr[0] = 88;
    // arr[1] = 99; // 不赋值，不会使用0填充，而是一个随机数

    int len = sizeof(arr) / sizeof(arr[0]);
    printf("\narr: len(arr) = %d | values = ", len);
    for (int i = 0; i < len; ++i) {
        printf("%d ", arr[i]);
    }

    // 二、定义时赋予初始化值
    int arr1[4] = {20, 30, 40, 50}; // 定义一个int数组，长度限定为4，为每个数组元素赋予初始值
    int arr2[4] = {15};             // 定义一个int数组，长度限定为4，为第一个数组元素赋予初始值，未赋初始值的，默认使用0填充，不会是随机数
    int arr3[4] = {0};              // 定义一个int数组，长度限定为4，所有元素均初始化为0（手动为第一个元素赋值0，其他均默认初始为0）
    int arr4[]  = {11, 22, 33, 44}; // 定义一个int数组，不指定长度，并初始化若干个数组元素，数组长度即为初始化元素的个数

    int len1 = sizeof(arr1) / sizeof(arr1[0]);
    printf("\narr1: len(arr1) = %d | values = ", len1);
    for (int i = 0; i < len1; ++i) {
        printf("%d ", arr1[i]);
    }

    int len2 = sizeof(arr2) / sizeof(arr2[0]);
    printf("\narr2: len(arr2) = %d | values = ", len2);
    for (int i = 0; i < len2; ++i) {
        printf("%d ", arr2[i]);
    }

    int len3 = sizeof(arr3) / sizeof(arr3[0]);
    printf("\narr3: len(arr3) = %d | values = ", len3);
    for (int i = 0; i < len3; ++i) {
        printf("%d ", arr3[i]);
    }

    int len4 = sizeof(arr4) / sizeof(arr4[0]);
    printf("\narr4: len(arr4) = %d | values = ", len4);
    for (int i = 0; i < len4; ++i) {
        printf("%d ", arr4[i]);
    }
}
# 输出结果：
arr: len(arr) = 2 | values = 88 -2005240448
arr1: len(arr1) = 4 | values = 20 30 40 50
arr2: len(arr2) = 4 | values = 15 0 0 0
arr3: len(arr3) = 4 | values = 0 0 0 0
arr4: len(arr4) = 4 | values = 11 22 33 44

2）一维数组的首地址：

#include <stdio.h>

void main() {
    // 数组名arr是一个只读变量，存储着数组的首地址（即：数组第一个元素的内存地址"&arr[0]"）
    // &arr[0]：实际上是两步运算，先取数组第一元素的变量arr[0]，然后再取第一个元素的内存地址；
    //         因为数组下标运算符"[]"优先级高于取地址运算符"&"，故可省略"()"，当然写成"&(arr[0])"也是对的
    int arr[] = {66, 88, 99};
    printf("The first element address of arr is: %p %p %p\n", arr, &arr[0], &(arr[0]));
}

# 输出结果：
The first element address of arr is: 0028FF34 0028FF34 0028FF34

3）一维数组元素内存地址的连续性：

#include <stdio.h>

void main() {
    // int数组每个元素占用4个字节大小的内存空间，各元素之间是紧邻排列的
    int arr[4] = {20, 30, 40, 50};
    for (int i = 0; i < 4; ++i) {
        printf("memory address %d is: %p\n", i, &arr[i]);
    }
}

# 输出结果：
memory address 0 is: 0028FF2C
memory address 1 is: 0028FF30
memory address 2 is: 0028FF34
memory address 3 is: 0028FF38

4）二维数组的定义和使用：

#include <stdio.h>

void main() {
    // 一、先定义后赋值（未赋值元素，不会使用0填充，而是一个随机数）
    int arr[3][2];
    arr[0][0] = 88;
    arr[1][0] = 66;

    int len_row = sizeof(arr) / sizeof(arr[0]);       // 行数
    int len_col = sizeof(arr[0]) / sizeof(arr[0][0]); // 列数
    printf("arr:");
    for (int i = 0; i < len_row; ++i) {
        printf("\nrow%d: ", i + 1);
        for (int j = 0; j < len_col; ++j) {
            printf("%d | ", arr[i][j]);
        }
    }

    // 二、定义时赋予初始化值
    // 1) 定义一个2行3列的二维int数组，为每个数组元素赋予初始值
    int arr1[2][3] = {
            {10, 20, 30},
            {18, 28, 38}
    };
    // 2) 定义一个2行3列的二维int数组，为部分数组元素赋予初始值，未赋初始值的，默认使用0填充，不会是随机数
    int arr2[2][3] = {
            {10, 20},
            {18}
    };
    // 3) 定义一个2行3列的二维int数组，所有元素均初始化为0（手动为第一个的元素赋值0，其他均默认初始为0）
    int arr3[2][3] = {0};
    // 4) 定义一个2行3列的二维int数组，按初始化一维数组的方式初始化二维数组的元素，C语言会根据二维数组定义的行列数自动将元素值给分配相应的二维数组元素
    int arr4[2][3] = {10, 20, 30, 18, 28, 38};
    // 5) 定义一个二维int数组，不指定行数但指定列数为3列，并初始化若干个数组元素，数组行数即为初始化元素的行数
    // 注：定义多维数组并初始化元素值，数组名后第一个[]中的值可以省略，后面的所有[]中的值均不可省略
    int arr5[][3]  = {
            {0},
            {18}
    };


    int len_row1 = sizeof(arr1) / sizeof(arr1[0]);       // 行数
    int len_col1 = sizeof(arr1[0]) / sizeof(arr1[0][0]); // 列数
    printf("\n\narr1:");
    for (int i = 0; i < len_row1; ++i) {
        printf("\nrow%d: ", i + 1);
        for (int j = 0; j < len_col1; ++j) {
            printf("%d | ", arr1[i][j]);
        }
    }

    int len_row2 = sizeof(arr2) / sizeof(arr2[0]);       // 行数
    int len_col2 = sizeof(arr2[0]) / sizeof(arr2[0][0]); // 列数
    printf("\n\narr2:");
    for (int i = 0; i < len_row2; ++i) {
        printf("\nrow%d: ", i + 1);
        for (int j = 0; j < len_col2; ++j) {
            printf("%d | ", arr2[i][j]);
        }
    }

    int len_row3 = sizeof(arr3) / sizeof(arr3[0]);       // 行数
    int len_col3 = sizeof(arr3[0]) / sizeof(arr3[0][0]); // 列数
    printf("\n\narr3:");
    for (int i = 0; i < len_row3; ++i) {
        printf("\nrow%d: ", i + 1);
        for (int j = 0; j < len_col3; ++j) {
            printf("%d | ", arr3[i][j]);
        }
    }

    int len_row4 = sizeof(arr4) / sizeof(arr4[0]);       // 行数
    int len_col4 = sizeof(arr4[0]) / sizeof(arr4[0][0]); // 列数
    printf("\n\narr4:");
    for (int i = 0; i < len_row4; ++i) {
        printf("\nrow%d: ", i + 1);
        for (int j = 0; j < len_col4; ++j) {
            printf("%d | ", arr4[i][j]);
        }
    }

    int len_row5 = sizeof(arr5) / sizeof(arr5[0]);       // 行数
    int len_col5 = sizeof(arr5[0]) / sizeof(arr5[0][0]); // 列数
    printf("\n\narr5:");
    for (int i = 0; i < len_row5; ++i) {
        printf("\nrow%d: ", i + 1);
        for (int j = 0; j < len_col5; ++j) {
            printf("%d | ", arr5[i][j]);
        }
    }
}

# 输出结果：
arr:
row1: 88 | 0 |
row2: 66 | 1962583106 |
row3: 1963197096 | 2686748 |

arr1:
row1: 10 | 20 | 30 |
row2: 18 | 28 | 38 |

arr2:
row1: 10 | 20 | 0 |
row2: 18 | 0 | 0 |

arr3:
row1: 0 | 0 | 0 |
row2: 0 | 0 | 0 |

arr4:
row1: 10 | 20 | 30 |
row2: 18 | 28 | 38 |

arr5:
row1: 0 | 0 | 0 |
row2: 18 | 0 | 0 |

5）二维数组的首地址：

#include <stdio.h>

void main() {
    // 二维数组名arr和arr[0]都是只读变量，存储着数组的首地址（即：数组第一个元素的内存地址"&arr[0][0]"）
    int arr[2][3] = {
            {10, 20, 30},
            {18, 28, 38}
    };
    printf("The first element address of arr is: %p %p %p\n", arr, arr[0], &arr[0][0]);
}

# 输出结果：
The first element address of arr is: 0028FF28 0028FF28 0028FF28

6）二维数组元素内存地址的连续性：

#include <stdio.h>

void main() {
    // 二维int数组每个元素占用4个字节大小的内存空间，各元素之间是紧邻排列的
    // 在内存中先存放二维数组的第一行元素，再存放第二行元素，依此类推
    int arr[2][3] = {
            {10, 20, 30},
            {18, 28, 38}
    };
    for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < 3; ++j) {
            printf("memory address [%d,%d] is: %p\n", i, j, &arr[i][j]);
        }
    }
}

# 输出结果：
memory address [0,0] is: 0028FF20
memory address [0,1] is: 0028FF24
memory address [0,2] is: 0028FF28
memory address [1,0] is: 0028FF2C
memory address [1,1] is: 0028FF30
memory address [1,2] is: 0028FF34

3、多维数组

三维数组内存地址的连续性：

#include <stdio.h>

void main() {
    // 三维char类型数组每个元素占用1个字节大小的内存空间，数组元素按深度遍历方式紧邻排列
    char arr[2][2][4] = {
            {
                {'a', 'b', 'c', 'd'},
                {'e', 'f', 'g', 'h'},
            },
            {
                {'1', '2', '3', '4'},
                {'5', '6', '7', '8'},
            }
    };
    for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < 2; ++j) {
            for (int k = 0; k < 4; ++k) {
                printf("memory address [%d,%d](%c) is: %p\n", i, j, arr[i][j][k], &arr[i][j][k]);
            }
        }
    }
}

# 输出结果：
memory address [0,0](a) is: 0028FF24
memory address [0,0](b) is: 0028FF25
memory address [0,0](c) is: 0028FF26
memory address [0,0](d) is: 0028FF27
memory address [0,1](e) is: 0028FF28
memory address [0,1](f) is: 0028FF29
memory address [0,1](g) is: 0028FF2A
memory address [0,1](h) is: 0028FF2B
memory address [1,0](1) is: 0028FF2C
memory address [1,0](2) is: 0028FF2D
memory address [1,0](3) is: 0028FF2E
memory address [1,0](4) is: 0028FF2F
memory address [1,1](5) is: 0028FF30
memory address [1,1](6) is: 0028FF31
memory address [1,1](7) is: 0028FF32
memory address [1,1](8) is: 0028FF33