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

KrisZhang10

已于 2023-10-31 20:23:06 修改

阅读量229

点赞数 3

分类专栏： C语言初阶文章标签： c语言

于 2023-10-31 20:22:31 首次发布

本文链接：https://blog.csdn.net/m0_61630449/article/details/134139164

版权

C语言初阶专栏收录该内容

12 篇文章 0 订阅

订阅专栏

本文详细介绍了C语言中数组的创建、初始化、内存布局，包括一维和二维数组，以及数组越界、作为函数参数的问题。特别提到C99标准引入的变长数组和正确处理数组尺寸的方法。

摘要由CSDN通过智能技术生成

一、数组的创建

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

数组的创建方式：

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

比如：

int arr1[10];
char ch[3+5];

用来指定数组大小的是不是一定只能用常量呢？

在C99标准之前，数组大小必须是常量表达式指定

在C99标准中，引入了变长数组的概念，变长数组中允许数组的大小用变量来指定。并且变长数组是不能初始化的。

二、数组的初始化

但是在非变长数组中

数组的初始化是指，在创建数组的同时给数组的内容一些合理初始值（初始化）。

如：

int arr1[10] = {1,2,3,4,5,6,7,8,9,10};//完全初始化
int arr2[10]={0};//非完全初始化
char arr3[10]={'a','b','c'};
char arr4[10]="abc";

如果数组初始化了，可以不指定数组的大小，数组的大小会根据初始化的内容来确定。

三、一维数组在内存中的存储

#include <stdio.h>

int main() 
{

    int arr[10] = {0};

    int i = 0;

    int sz = sizeof(arr)/sizeof(arr[0]);

    for(i=0; i<sz; ++i)

{

        printf("&arr[%d] = %p\n", i, &arr[i]);

} 
return 0;

}

%p：打印地址。打印结果：

可以观察到：1、数组在内存中是连续存放的。

2、随着下标的增长，地址是由低到高变化的。

是什么类型的指针+1就跳过什么类型的元素

四、二维数组

创建

//数组创建 
int arr[3][4];
 char arr[3][5];

初始化

正常初始化，自动填充每一行

int arr1[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};

想把1、2 放第一行，2、3放第二行，3、4放第三行

int arr1[3][4] = {{1,2},{3,4},{5,6}};

注意⚠️在二维数组中，创建初始化的时候行可以省略，列不能省略

C语言规定行列都是从0开始的。

比如如果要找到1行2列的元素就要这样写：

printf("%d\n",arr[1][2]);

访问每一个元素

五、二维数组在内存中的存储

所以二维数组在内存中仍然是连续存放的

如果把二维数组的每一行看做一个一维数组，那么每一行的一维数组也有数组名

arr[0]就是第一行的数组名

arr[1]就是第二行的数组名，以此类推

六、数组越界

数组的下标是有范围限制的。

数组的下规定是从0开始的，如果数组有n个元素，最后一个元素的下标就是n-1。

所以数组的下标如果小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。

C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的。

所以程序员写代码时，最好自己做越界的检查。

二维数组的行和列也可能存在越界。

七、数组作为函数参数

往往我们在写代码的时候，会将数组作为参数传给函数。

比如：我要实现一个冒泡排序（这里要讲算法思想）函数将一个整形数组进行排序。

核心思想参考：

Comparison Sorting Visualization

写出代码：

#include <stdio.h>

 void bubble_sort(int arr[])
 {

     int sz = sizeof(arr)/sizeof(arr[0]);//这样对吗？
     int i = 0;
     //冒泡排序一般都是两个for循环写的
     for(i=0; i<sz-1; i++)//这一层控制循环的趟数
     {
         int j = 0;//一趟冒泡排序的过程
         for (j = 0; j < sz - i - 1; j++)
         {
            if(arr[j]>arr[j+1])
            {
                int tmp;
                tmp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=tmp;
            }
         }
     }
 }
 
int main()
{
    int arr[] = {3,1,7,5,8,9,0,2,4,6};
    //排序 - 升序
    //冒泡排序
    int i = 0;
    bubble_sort(arr);
    for(i=0; i<sizeof(arr)/sizeof(arr[0]);i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

运行后发现，不符合预期。

可以看到sz并不对

八、数组名是什么？

#include <stdio.h> 

int main()
 {
    int arr[10] = {1,2，3,4,5}; 
    printf("%p\n", arr); 
    printf("%p\n", &arr[0]);
    printf("%d\n", *arr); //输出结果 
    return 0;

}

数组名是数组首元素的地址。

如果数组名是首元素地址，那么：

    int arr[10] = {0}; 
    printf("%d\n", sizeof(arr));

为什么输出的结果是：40？

⚠️注意！！！

数组名是数组首元素的地址

但是有2个例外：

sizeof（数组名）,数组名如果单独放在sizeof内部,这里的数组名表示整个数组，计算的是整个数组的大小

&数组名，这里的数组名表示整个数组，取出的是整个数组的地址。

除此之外，遇到的所有数组名都是数组首元素的地址。

所以说 bubble_sort(arr);这一句只是传的首地址，void bubble_sort(int arr[])，前面传的地址，所以后面int arr[]本质上就是一个指针。那么 int sz = sizeof(arr)/sizeof(arr[0]);中的sizeof(arr)在32位是4字节，而64位是8字节，所以8/2=4。

所以进行纠正：

#include <stdio.h>

 void bubble_sort(int arr[],int sz)
 {


     int i = 0;
     //冒泡排序一般都是两个for循环写的
     for(i=0; i<sz-1; i++)//这一层控制循环的趟数
     {
         int j = 0;//一趟冒泡排序的过程
         for (j = 0; j < sz - i - 1; j++)
         {
            if(arr[j]>arr[j+1])
            {
                int tmp;
                tmp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=tmp;
            }
         }
     }
 }

int main()
{
    int arr[] = {3,1,7,5,8,9,0,2,4,6};
    //排序 - 升序
    //冒泡排序
    int i = 0;
    int sz = sizeof(arr)/sizeof(arr[0]);
    bubble_sort(arr,sz);
    for(i=0; i<sizeof(arr)/sizeof(arr[0]);i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}