啊，爬到数组

冷色调的火

已于 2022-09-29 22:06:21 修改

阅读量98

点赞数

文章标签： c语言

于 2022-08-22 03:14:02 首次发布

本文链接：https://blog.csdn.net/m0_69460362/article/details/126448135

版权

本文详细介绍了如何创建和初始化一维和二维数组，探讨了一维数组连续存储的特点，以及二维数组的初始化示例和内存布局。此外，还涵盖了数组越界问题、作为函数参数的应用，如冒泡排序，并解析了数组名的含义和二维数组行列计算的方法。

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

1.一维数组的创建和初始化

1.1数组的创建

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

数组的创建方式:

int//数组的元素类型 arr//数组名[]//放常量或常量表达式，用来指定数组大小

1.2数组的初始化

在创建数组的同时给数组一些合理的初始值

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
    int arr1[] = {1,2,3,4};
    char arr2[] = "abcde";
    char arr3[] = '\0';
    char arr4[] = { 'a','b','c','d' };
    char arr5[] = { 'a','b','c',98 };
    
    //不完全初始化,剩余的元素默认初始化为0
    char arr6[10] = { 'a','b','c' };

    //存放了a b c 0 0 0 0 0 0 0

    char arr7[10] = "abc";
    //存放了a b c \0 0 0 0 0 0 0

    //注意两种写法不同，也就是说第二种写法必须要多预留一个位置

    int pa[10] = { 1, 2, 3 };
    //完全初始化
    char str[10] = { 'a','b','c','d','e','f','g','h','i','j' };
    int pa[10] = { 1,2,3,4,5,6,7,8,9,0 };

    return 0;
}

2.一维数组的使用

[ ]下标引用操作符，专门用来访问数组的操作符

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };

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

    for(i = 0; i < sz; i++)
{
    printf("%d",arr[i]);
}

    return 0;
}

总结：数组是通过下标来访问的，下标·是从0开始的

数组的大小可以通过计算获取

3.一维数组在内存中的存储


#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,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;
}

可以看到一维数组的地址是连续的

随着数组下标的增长，元素的地址也在有规律的递增，一维数组在内存中是连续存放的

4.二维数组的创建和初始化

创建：

//二维数组的创建
int arr[3][4];

初始化

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
    int arr[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
    //1,2,3,4
    //5,6,7,8
    //9,10,11,12

    int str[3][4] = { {1,2},{2,3},{3,4} };
    //1,2,0,0
    //2,3,0,0
    //3,4,0,0

    int prr[][4] = { {1,2,3,4},{1,2} };//可以省略行，不能省略列
    //1,2,3,4
    //1,2,0,0

    return 0;
}

5.二维数组的使用

#define _CRT_SECURE_NO_WARNINGS
#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++)
        {
            scanf("%d",&arr[i][j]);
        }

    }

    for(i = 0; i < 3; i++)
    {
        for(j = 0; j < 4; j++)
        {
            printf("%d ",arr[i][j]);
        }
    printf("\n");
    }

    return 0;
}

6.二维数组在内存中的存储

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
    int arr[3][4] = { 1,2,3,4,2,3,4,5,3,4,5,6 };
    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]);
        }
    }

    return 0;
}

二维数组在内存中也是连续存在的

7.数组越界

数组的下标是有限制的，数组的下标规定是从0开始的，如果数组有n个元素，最后一个元素的下标就是n-1,要注意数组越界不一定会报错

例如

一维数组的越界

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
    int arr[] = { 1,2,3,4,5 };
    int i = 0;
    for(i = 0; i < 10; i++)
    {
        printf("%d",arr[i]);
    }

    return 0;
}

可以利用sizeof求数组长度规避

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
    int arr[] = { 1,2,3,4,5 };
    int sz = sizeof(arr)/sizeof(arr[0]);

    for(i = 0; i < sz; i++)
    {
        printf("%d",arr[i]);
    }
    return 0;
}

二维数组的越界

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
    int arr[3][4] = { 1,2,3,4,2,3,4,5,3,4,5,6 };
    int i = 0;
    int j = 0;
    
    for(i = 0; i < 3; i++)
    {
        for(j = 0; j <= 4; j++)
//这里的j<=4越界了，前面是在自己的范围内越界，走到后面就会越出自己的范围
        { 
            printf("%d",arr[i][j]);
        }
    }
    return 0;
}

8.数组作为函数参数

8.1冒泡排序

冒泡排序的思想：

两个相邻元素进行比较，一趟冒泡排序会让一个数据来到它最终的位置

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

//数组传参的时候形参有两种写法
//1.数组形式
//2.指针形式
//

//形参是数组的形式
void bubble_sort(int arr[],int sz)
//形参是指针的形式
//void bubble_sort(int* arr,int sz)
{
    //先确定躺数
    int i = 0;
    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 = arr[j+1];
                arr[j+1] = arr[j];
                arr[j] = tmp;
            }
        }
    }
}

int main()
{
    //
    //给数组元素升序
    //
    int arr[] = { 9,8,7,6,5,4,3,2,1,0 };

    //1,2,3,4,5,6,7,8,9
//利用冒泡排序的算法对数组进行排序
    int sz = sizeof(arr)/sizeof(arr[0]);
    int i = 0;
    bubble_sort(arr,sz);

    for(i = 0; i < sz; i++)
    {
        printf("%d",arr[i]);
    }
    return 0;
}

8.2数组名是什么

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
    int arr[10] = { 0 };

    printf("%p\n",arr);
    printf("%p\n",&arr[0]);
 //对比数组名和数组首元素地址，运行后发现二者地址相同，目前得出初步结论，数组名就是数组首元素地址

    int n = sizeof(arr);
    printf("%d",n);
//如果数组名代表首元素地址，那么这里的n应该等于4，但是结果打印出40

//总结：数组名可以代表首元素地址但是有两个例外
//1.sizeof(数组名)，这里的数组名代表整个数组，是计算整个数组的大小，单位是字节
//2.&数组名，这里的数组名也代表整个数组，取出的是整个数组的地址
    return 0;
}

总结：数组名可以代表首元素地址但是有两个例外
1.sizeof(数组名)，这里的数组名代表整个数组，是计算整个数组的大小，单位是字节
2.&数组名，这里的数组名也代表整个数组，取出的是整个数组的地址

对于第二条的理解


int arr[10] = { 0 };

printf("%p",arr);
printf("%p",arr+1);
//这里的地址跳过4个字节

printf("%p",&arr[0]);
printf("%p",&arr[0]+1);
//这里的地址跳过4个字节


printf("%p",&arr);
printf("%p",&arr+1);
//这里的地址直接跳过40个字节

二维数组的数组名理解

int main()
{
    int arr[3][4] = { 0 };
    int sz = sizeof(arr);

    printf("%d",sz);//48

    return 0;
}

二维数组名的理解和一维数组名的理解相似

二维数组的数组名代表二维数组的首元素地址，这时应该把二维数组理解为一维数组，那么二维数组的数组名就是第一行首元素的地址，第一行首元素的地址，就代表了第一行元素的地址（这个说法更容易理解，实际二维数组在内存中是连续存放的）

int arr[3][4] = { 0 };

arr;

arr+1;//会跳过16个字节，因为二维数组名代表首元素地址，把二维数组理解为一维数组，这里的首元素就指第一行首元素的地址，加1后就会跳到第二行首元素的地址

会跳过16个字节，因为二维数组名代表首元素地址，把二维数组理解为一维数组，这里的首元素就指第一行首元素的地址，加1后就会跳到第二行首元素的地址

计算二维数组的行列

int main()
{
    int arr[3][4] = { 0 };
    //行
    int row = sizeof(arr)/sizeof(arr[0]);
//二维数组数组名单独放在sizeof内部代表整个数组，通过计算得到整个二维数组的大小，arr[0]代表二维数组的一行，通过计算得到二维数组一行元素的总大小
    //列
    int line = sizeof(arr[0])/sizeof(arr[0][0]);
//arr[0]代表二维数组的一行，通过计算得到二维数组一行元素的总大小，arr[0][0]代表二维数组一个元素的大小

    return 0;
}