数组详解-优快云博客

本文链接：https://blog.youkuaiyun.com/aqlll_/article/details/128184984

数组之一

什么是数组呢？
1、一维数组
2、二维数组
3、数组越界

什么是数组呢？

数组是一组相同类型元素的集合

1、一维数组

1.1 一维数组的创建

type_t arr_name [const_n];
//type_t是数组元素类型
//const_n是一个常量表达式，指定数组的大小

注意：在C99标准之前，[ ] 中必须要给个常量，不能用变量。在C99标准中支持了变长数组的概念，就是数组的大小可以用变量，但是此时数组就不能初始化了。

1.2 一维数组的初始化

int main()
{
    //创建的同时，给数组一些值，叫做初始化
    int arr1[10] = {1,2,3,4,5,6,7,8,9,10};//完全初始化
    int arr2[10] = {1,2,3};//不完全初始化，剩余的元素默认初始化为0
    int arr3[] = {1,2,3,4,5,6,7,8,9,10};//不指定数组元素个数，编译器会根据初始化的内容数量来确定数组的元素个数
    int arr4[] = {1,2,3};
    int arr5[10] = {1,2,3};//arr4和arr5是不一样的
    char arr6[3] = {'a','b','c'};
    char arr7[] = {'a','b','c'};//就是只有3个元素
    char arr8[10] = "abc";//有4个元素，实际上是a b c \0
    char arr9[] = "abc";//arr9有4个元素       
    return 0;
}
//全局数组和全局变量一样，不初始化的话自动全是0.未初始化的全局数组默认都是\0

1.3 一维数组的使用

//打印数组
#include<stdio.h>
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    int sz = sizeof(arr) / sizeof(arr[0]);
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

[ ] 是下标引用操作符。

1.4 一维数组在内存中的存储

以下代码运行的结果是什么呢？

#include<stdio.h>
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    int sz = sizeof(arr) / sizeof(arr[0]);
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("&arr[%d] = %p \n", i, &arr[i]);
    }
    return 0;
}

结果如下：
在这里插入图片描述

因为一个整型是4个字节的大小，每个整型数组元素都在内存中占用4个字节。
一维数组在内存中是连续存放。
且随着数组下标的增加，内存也是由低地址到高地址变化的。

一个小题外话，关于指针与数组：

//用下标打印一维数组
#include<stdio.h>
int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    int i = 0;
    int* p = &arr[0];
    for (i = 0; i < sz; i++)
    {
        printf("%d ",*(p + i));
    }
    return 0;
}
//因为指针p是int型的，所以p+1就是往后跳4个字节

2、二维数组

2.1 二维数组的创建

和一维数组类似：

type_t arr_name [const_n][const_m];
//type_t是数组元素类型
//const_n和const_m是常量表达式，指定数组的大小

2.2 二维数组的初始化

//数组初始化
int arr[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};//这也是可以的
int arr[3][4] = {{1,2,3},{4,5,6},{7,8,9},{10,11,12}};//和上面的是一样的
int arr[3][4] = {1,2,3,4};//其余的都是0
int arr[3][4] = {{1,2},{4,5}};//其余的都是0
int arr[][4] = {{2,3},{4,5}};//二维数组如果有初始化，行可以省略，列不能省略
int arr[][2] = {1,2,3,4,5,6,7,8,9,10};//就是5行2列

2.3 二维数组的使用

这里用到了两层的循环：

//打印二维数组
#include<stdio.h>
int main()
{
    int arr[][2] = {1,2,3,4,5,6,7,8,9,10};
    int i = 0;
    int j = 0;
    for(i = 0; i < 5; i++)
    {
        for(j = 0; j < 2; j++)
        {
            printf("%d ",arr[i][j]);        
        }    
        printf("\n");
    }
    return 0;
}

2.4 二维数组在内存中的存储

下面代码的运行结果是怎样的呢？

#include<stdio.h>
int main()
{
    int arr[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
    int i = 0;
    int j = 0;
    for(i = 0; i < 3; i++)
    {
        for(j = 0; j < 4; j++)
        {
            printf("&arr[%d][%d] = %p \n", i, j, &arr[i][j]);        
        }    
        printf("\n");
    }
}

运行结果如下：
在这里插入图片描述

可见：二维数组在内存中也是连续存放着的

对此结果，不难想到，二维数组的打印可以通过指针来实现：

#include<stdio.h>
int main()
{
    int arr[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
    int i = 0;
    int j = 0;
    int* p = &arr[0][0];
    int k = 0;
    for(k = 0; k < 12; k++)
    {
        printf("%d ", *(p + k));        
    }
    return 0;
}

注意：二维数组的每一行都可以理解为一个一维数组，arr[0]、arr[1]、arr[2]…可以看作一个一维数组的数组名
对于二维数组：
行数：sizeof(arr) / sizeof(arr[0])
列数：sizeof(arr[0]) / sizeof(arr[0][0])

3、数组越界

什么是数组越界？
就是当数组只有n个元素时，访问下标小于0的元素和下标大于n-1的元素，就是数组越界。
如下代码就是越界：

#include<stdio.h>
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    int i = 0;
    for(i = 0; i <= 10; i++)
    {
        printf("%d\n",arr[i]);    
    }
    return 0;
}
//这个代码访问了第11个元素，而数组只有10个元素，所以越界了，
//会打印出随机值，虽然编译器不报错，但是这是错误的代码