【C语言】初始数组中的一维数组和二维数组，以及数组如何作为函数参数

原创于 2024-12-10 15:56:20 发布 · 1.1k 阅读

24 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#算法 #c语言

一维数组的创建与初始化。

数组的创建

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

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

int main(){
    //创建整型数组，存放十个整形元素
    int arr[10];
    //创建字符数组，存放十个字符串
    char arr2[10];

    //指定数组大小时，要用常量
    return 0;
}

数组的初始化

在创建数组的时候，给数组内部一些合理化的初始值。

如果使用不当的初始化方式，（int arr[10] = {1,2,3}，那么剩下的元素，会被默认初始化为0），这个过程便叫作不完全初始化

字符串数组相同

数组中容易混淆的sizeof和strlen

#include <stdio.h>
#include <string.h>
int main(){
    char arr[] = "abcdef";
    printf("%d\n",sizeof(arr));
    //sizeof计算arr所占空间的大小；arr里面有七个元素，
    printf("%d\n",strlen(arr));
    //strlen计算arr的字符串长度；找到\0停止，而且不会把\0算进去
    return 0;
}

通过以上代码，我们可以了解到数组字符串中sizeof和strlen的用法，那么你觉得，下面代码中，打印出来的值分别会是什么呢

#include <stdio.h>
#include <string.h>

int main(){
    char arr1[] = "abc";
    char arr2[] = {'a','b','c'};
    printf("%d\n", sizeof(arr1));
    printf("%d\n", sizeof(arr2));
    printf("%d\n", strlen(arr1));
    printf("%d\n", strlen(arr2));
    return 0;
}

一维数组的使用

下标引用操作符（[]访问数组元素的操作符）

#include <stdio.h>
#include <string.h>
int main(){
    char arr[] = "abcdef";//[a] [b] [c] [d] [e] [f] [\0]
    //想要打印哪个元素，就直接打印对应元素的下标
    printf("%c\n", arr[3]);//打印d 

    //如果想要打印出整个字符串，用循环遍历的操作
    for(int i = 0; i < 6; i++){
        printf("%c", arr[i]);
    }

    //亦或者，让i小于字符串长度也可以
    int len = strlen(arr);
    for(int i = 0; i < len; i++){
        printf("%c", arr[i]);
    }
    return 0;
}

对应整形元素，打印出整串数组可以用sizeof完成操作

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

一维数组在内存中的存储
#include <stdio.h>
int main(){
    int arr[] = {1,2,3,4,5,6,7,8,9};
    int sz = sizeof(arr) / sizeof(arr[0]);
    for(int i = 0; i < sz; i++){
        printf("%d的地址是%p。\n", arr[i] , &arr[i]);
    }
    return 0;
}
可以发现，16进制中，每个元素之间都差4；又因为每个元素占4个字节，我们可以发现，1到9的地址由低到高，在内存中是连续存放的。

二维数组的创建与初始化

数组的创建

首先，在创建一个二维数组前，我们来认识一下什么叫做二维数组。



        在我们的常识中，一维是一个点，二维是一个面，三维是一个空间，四维加上了时间的概念……

我们的二维数组也是如此，它是一个类似面的空间。
//二维数组
int arr[8][5];
第一个表示行；
第二个表示列；

它表示一个如下的面空间
[][][][][]
[][][][][]
[][][][][]
[][][][][]
[][][][][]
[][][][][]
[][][][][]
[][][][][]

二维数组初始化

认识完二维数组，接下来我们就来创建一个二维数组
#include <stdio.h>
int main(){
    int arr[3][4];
    return 0;
}

/*
表示的空间：
[][][][]
[][][][]
[][][][]
*/
假设，我要初始化这个二维数组，那我能不能用下面的创建方式呢？
#include <stdio.h>
int main(){
    int arr[3][4] = {1，2，3，4，5};
    return 0;
}
一行只能放四个元素，那我放置第五个元素是否合法呢？

可以看到，我的第五个元素跑到了第二行中；然而第二行剩下未进行初始化的元素，和第三行未进行初始化的元素，都变成了0，这符合我们的不完全初始化的规律。

Question：如果我想把123放在第一行，45放置第二行，该如何操作呢？

二维数组其实就是多个一维数组混合后的产物，我们完全可以把第一行的一维数组看作是一个数组，第二行的一维数组看作是一个数组……这样，我们再在数组之中进行数组定义即可。
#include <stdio.h>

int main(){
    int arr[3][4] = {{1,2,3},{4,5}};
    return 0;
}
注：我们在创建一维数组时，可以先不在访问操作符[]中写我元素的个数，而是通过后面我的初始化来告诉数组我有多少个元素；

而在二维数组中，列不能被省略，行可以被省略。

二维数组的使用

二维数组的使用，也是从下标入手。

二维数组在内存中的存储
int main(){
    int arr[3][4] = {{1,2,3},{4,5}};
    for(int i = 0; i < 3; i++){
        for(int j = 0; j < 4; j++){
            printf("&arr[%d][%d] = %p\n", i, j , &arr[i][j]);
        }
    } 
    return 0;
}
打印结果如下

可以看出，每个元素之间相差的依旧是4个字节空间，即便是行与行之间，也是仅仅相差4个空间。

然而，在我们的假想中，二维数组空间分布应该是这样的

然而，在实际情况中，二维数组和一维数组一样，每个元素彼此之间都是前后相靠的。

我们只是为了更加方便的思考，所以才会采用假想的二维空间。

数组作为函数参数

往往在我们写代码的时候，会将数组作为参数传给函数；比如，我要实现一个冒泡排序函数将一个整数数组继续升序的排序。那我们将会这样使用该函数：

（错误代码）

#include <stdio.h>
void bubblesort(int arr[]){
    int sz = sizeof(arr) / sizeof(arr[0]);
    for(int i = 0; i < sz - 1; i++){
        int flag = 1;
        for(int j = 0; j <sz - i - 1; j++){
            if(arr[j] > arr[j + 1]){
                if(arr[j] > arr[j + 1]){
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = 0;
                }
            }
        }
        if(flag == 1){
            break;
        }
    }
}
int main(){
    int arr[10] = {9,8,7,6,5,4,3,2,1,0};
    int sz = sizeof(arr) / sizeof(arr[0]);
    bubblesort(arr);//arr是数组，我们对数组进行传参，实际上传递过去的是数组arr首元素的地址 &arr[0]
    for(int i = 0; i < sz; i++){
        printf("%d ",arr[i]);
    }
    return 0;
}

因为在传递过程中，我们实际上传过去的是arr的首元素的地址，这也就导致我们在调用冒泡排序的时候，不能通过sizeof计算我们的元素个数（sizeof(arr)和sizeof(arr[0])在32位系统中和64位系统中，分别为都是4和8的指针）

正确做法是，在一开始传递的时候，就将我们计算出的数组个数传递过去

#include <stdio.h>
void bubblesort(int arr[], int sz){
    for(int i = 0; i < sz - 1; i++){
        int flag = 1;
        for(int j = 0; j <sz - i - 1; j++){
            if(arr[j] > arr[j + 1]){
                if(arr[j] > arr[j + 1]){
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = 0;
                }
            }
        }
        if(flag == 1){
            break;
        }
    }
}
int main(){
    int arr[10] = {0,1,2,3,4,5,6,7,8,9};
    int sz = sizeof(arr) / sizeof(arr[0]);
    bubblesort(arr,sz);
    for(int i = 0; i < sz; i++){
        printf("%d ",arr[i]);
    }
    return 0;
}

在该代码中，我们应牢记，数组名在传参中，就是首元素的地址

加深影响：
#include <stdio.h>
int main(){
    int arr[] = {1,5,6,8,2,3};
    printf("%p\n", arr);
    printf("%p\n", &arr[0]);
    printf("%d\n", *arr);
    return 0;
}
//思考，两个printf打印出来的值，会不会相同呢，如果数组名真的是首元素地址，那么解引用数组名，会不会打印出1呢？
    
由上图可知，数组名就是首元素的地址

数组名不是首元素地址的例外

在通常情况下，数组名就是首元素的地址，但是有两个例外。
#include <stdio.h>
int main(){
    int arr[10] = {0};
    printf("%d\n", sizeof(arr));
    return 0;
}
打印结果是40；
int main(){
    int arr[10] = {0};
    printf("%d\n", sizeof(arr));
    printf("%p\n", &arr[0]);
    printf("%p\n", arr);
    printf("%p\n", &arr);
    return 0;
}
虽然&arr和arr以及&arr[0]的结果相同，但&arr表示的是整个数组的地址。

通过对每项打印结果+1，我们可以清晰的看出差距

可以看到，前两项arr + 1以及&arr[0] + 1都是加了4字节的空间，这符合数组首元素 + 1后移动4字节空间的原理；然而&arr + 1后，地址增加了整整40。这是因为我们的数组有10个元素，每个元素移动4字节后，增加了 10 * 4 = 40的字节。