个人中心
gpt4 book ai didi

一篇文章带你入门C语言:数组

转载 作者：qq735679552 更新时间：2022-09-27 22:32:09 33 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章一篇文章带你入门C语言:数组由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

数组

一维数组

创建 定义 。

数组是一组相同类型的元素的集合。那数组的语法形式:

?
1
2
3
type_t arr_name [const_n]
//如：
int arr[10];

type_t 指的是数组元素的类型.

const_n 指的是一个常量表达式，用来指定数组的大小.

此时运行程序的话，系统会报一个警告：未初始化变量。打开调试就会发现系统默认填入一些无意义的数据.

一篇文章带你入门C语言:数组

当然全局数组的话，系统默认初始化为0； 。

?
1
2
3
4
int arr[10]; // 0 0 ... 0
int main(){
   return 0;
}

创建实例 。

?
1
2
3
4
5
6
7
8
//1.   
int arr[10];
//2.
int count = 10;
int arr2[count]; //这样的创建数组可不可以呢？
//3.
float arr3[20]; //浮点型数组
char ch[10];

数组的创建必须要[]使用常量，不能使用变量。（ps：虽然c99支持变长数组，但一般用常数创建就已经够用了）同样，我虽然用const_n表示常量，但可千万不要误会为const修饰的变量哦.

为什么呢?

因为数组控制不好容易越界访问非法内存，用变量的话风险太大，所以一直以来都是用常量创建数组的.

初始化

初始化，顾名思义，在创建数组的同时给予一些合理的初识值。如:

?
1
int arr[10] = { 1,2,3 }; //不完全初始化

这种是不完全初始化，剩余的元素默认是0 。

?
1
int arr2[] = { 1,2,3,4 }; //利用初始化内容，指定数组大小

这种是省略数组的const_n常量表达式 。

由初始化内容指定数组的大小 。

那下面这三个有什么不同呢?

一篇文章带你入门C语言:数组

第一种是用字符串初始化数组，字符串有\0作为结束标志，虽不算字符串内容，但是可以说是字符串与生俱来的，所以它也被初始化作为数组内容。a b c \0 。

第二种和第三种是一样的，因为数组元素类型是字符型，且字符'b'的acsii码值是98，自动将98解析为字符。a b c 。

使用

数组的访问是通过下标来访问的，默认下标是从0开始。通过下标引用操作符[]我们可以访问到数组元素.

?
1
2
3
4
5
6
7
8
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//数组的下标是从0开始的0~9
int sz = sizeof (arr) / sizeof (arr[0]); //10
for ( int i = 0; i < sz; i++)
{
     printf ( "%d " , arr[i]);
}
//1 2 3 4 5 6 7 8 9 10

对于sizeof操作符，sizeof(arr)，即sizeof+数组名，指的是计算整个数组的大小，算出来是40，然后sizeof(arr[0])是计算数组首元素的大小为4，这样一除就是元素个数啦.

使用变量sz，可以灵活的改变数组的大小，就不用再更改循环条件了.

总结：

  • 数组是通过下标访问的，下标从0开始
  • 数组的大小可以通过计算得到

内存存储

一篇文章带你入门C语言:数组

通过printf("&arr[%d]=%p\n", i,&arr[i]);这样的语句我们可以看到该数组在内存中的存储情况.

很明显的是，数组在内存中是连续存放的.

一篇文章带你入门C语言:数组

右边是十六进制的内存编号，可以看见每一个元素之间都相差4个字节，而一个整型元素正好占4个字节.

所以数组在内存中是连续存放的，随着数组下标的增长，地址也在增长，这也正是为什么指针变量+1，可以访问到下一个数组元素.

所以数组的本质是什么?

一组内存中连续存放的相同类型的元素.

二维数组

创建

?
1
2
3
4
5
type_t arr_name[const_n][const_n]
//
int arr[3][5]; //3行5列
char ch[4][7]; //4行5列
double arr2[2][4] //2行4列

如上述代码所示：二维数组的语法结构就是，类型+数组名+[行][列].

一篇文章带你入门C语言:数组

如图所示，二维数组在理解上就是这样的3行5列类似于表格的东西。就像线性代数里的矩阵，矩阵的定义就是一组数组成数表.

初始化

?
1
2
3
4
//1.
int arr1[3][5] = { 1,2,3,4,5,6,7,8,9,10,11 };
//2.
int arr2[3][5] = { {1,2},{3,4},{5,6,7} };
第一种初始化，先一行一行填入，第一行是1 2 3 4 5，第二行是6 7 8 9 10，第三行不够就补零11 0 0 0 0 。第二种的话，把每一行看成一个一维数组，不够的话还是补零，即第一行1 2 0 0 0，第二行3 4 0 0 0，第三行5 6 7 0 0 。

一篇文章带你入门C语言:数组

?
1
2
3
char ch1[2][4] = { 'a' , 'b' };
char ch2[2][4] = { { 'a' },{ 'b' } };
char ch3[3][4] = { "abc" , "def" , "gh" };

当然用字符串去初始化二维数组的话，也是需要注意\0的问题.

第一行：a b c \0；第二行：d e f \0；第三行：g h \0 0 。

省略 。

?
1
int arr2[][5] = { {1,2},{3,4},{5,6,7} };

像这样省略行可以，但是不能省略列.

行数可以根据初始化内容来规定，但如果列省略了就会造成歧义.

当然，省略必须在已经初始化的前提之下，不然行和列一概不知，怎么分配空间呢?

使用 。

当然二维数组同样是用下标访问数组内容的，也是从0开始。如:

一篇文章带你入门C语言:数组

我们要去访问这个二维数组的话，我们当然是用两次循环遍历这个数组.

一篇文章带你入门C语言:数组

内存存储 。

当然我们也可以用同样的办法打印出每个元素的地址，如:

一篇文章带你入门C语言:数组

我们还是能发现每一个元素都是在内存中连续存放的.

这样的话，二维数组在内存中的存储形式便是大家想象中的二维的形式，把每一行理解为一个一维数组，这样的话二维数组在内存中的存储形式还是一维的。如下图的对比:

一篇文章带你入门C语言:数组

从这里我们也可以理解到，二维数组的初始化里，为什么可以省略行不能省略列.

把行省略了，但是我们知道列，一个一个填满就是了，能填到多少行就有多少行.

理解方式 。

对于二维数组，我们可以理解为每一行为一个元素的一维数组，该一维数组的每一个元素又是一个一维数组.

如数组arr[3][5] ，是有3个元素的一维数组，每个元素是一个有5个元素的一维数组.

指向二维数组的指针+1，指向的是下一行.

对于二维数组在内存存储形式的理解还是很重要的，有了这样的思想，我们就可以通过指针遍历得到数组元素，如:

?
1
2
3
4
5
6
int arr[3][5] = { {1,2,3},{4,5,6},{7,8} };
int * p = &arr[0][0];
for ( int i = 0; i < 15; i++)
{
     printf ( "%d " , *p++); //1 2 3 0 0 4 5 6 0 0 7 8 0 0 0
}

数组越界问题

定义 。

数组通过下标访问，那么下标也就可以控制数组的访问范围。在数组前后进行访问的话，就是非法访问内存，即数组越界.

?
1
2
3
4
5
6
//1 2 3 4 5 -858993460
int arr[5] = { 1,2,3,4,5 };
for ( int i = 0; i <= 5; i++) //越界访问到第6个
{
     printf ( "%d " , arr[i]);
}

数组越界访问到最后一个元素之后的一块内存，这就属于越界访问，-858993460是vs2019自动生成的随机值.

一般编译器是不会去检查数组越界访问的情况（vs2019太先进），所以我们就要有意识的主动检查。如果编译器提示这样的错误信息，那么一般就是数组越界了:

一篇文章带你入门C语言:数组

数组作函数参数

在写代码时，我们经常会将数组作为参数，比如接下来的两个应用实例，那么我们这里以冒泡排序的实现作为案例.

排序算法一般有四种：冒泡排序、选择排序、插入排序和快速排序.

冒泡排序的核心思想：两两相邻的元素进行比较.

  • 一趟冒泡排序搞定一个数字，让其来到最终的位置上。
  • n n n 个元素，则总共需要 n − 1 n-1 n−1 趟冒泡排序，每一趟排序需要进行 n − 1 − i n-1-i n−1−i 次判断大小。

如分析图所示:

一篇文章带你入门C语言:数组

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
void print( int * arr, int sz)
{
     for ( int i = 0; i < sz; i++)
     {
         printf ( "%d " , *arr++);
     }
}
void sort( int arr[], int sz) //int* arr
//数组作形参本质是指针
{
     //int sz = sizeof(arr) / sizeof(arr[0]);//err//用指针的sizeof值除以另一个值 = 4 / 4 = 1
     for ( int i = 0; i < sz - 1; i++) //n-1趟
     {
         for ( int j = 0; j < sz - 1 - i; j++) //n-1-i次
         {
             if (arr[j] > arr[j + 1]) //目标升序
             {
                 //交换
                 int tmp = arr[j];
                 arr[j] = arr[j + 1];
                 arr[j + 1] = tmp;
             }
         }
     }
}
int main()
{
     int arr[] = { 1,4,6,3,7,9,3,2,8,5 };
     int sz = sizeof (arr) / sizeof (arr[0]);
     //数组名单独放在sizeof中，表示整个数组
     //排序
     sort(arr,sz);
     //打印
     print(arr,sz);
     return 0;
}

1.定义数组作形参时，本质上是指针.

void sort(int *arr,int sz)本质上就是void sort(int arr[],int sz) 。

所以sort()函数内，sizeof(arr)也算的就是指针arr的大小，所以只能传参进去.

2.数组名arr何时代表整个数组何时代表数组首元素地址呢?

  • 代表整个数组的情况：

单独放在sizeof操作符内部时，如sizeof(arr); .

写出&arr时，代表的是整个数组，但表面仍为首元素地址.

  • 代表首元素地址的情况：

除上面两以外其他都是代表首元素的地址.

应用实例

笔者实在没时间写两个应用实例的博客，所以在此将思维导图奉上，一般照着思维导图写就没问题了。感谢李姐和支持~ 。

数组的应用实例1：三子棋 。

一篇文章带你入门C语言:数组

数组的应用实例2：扫雷游戏 。

一篇文章带你入门C语言:数组

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注我的更多内容！ 。

原文链接：https://blog.csdn.net/yourfriendyo/article/details/119220196 。

最后此篇关于一篇文章带你入门C语言:数组的文章就讲到这里了,如果你想了解更多关于一篇文章带你入门C语言:数组的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

33 4 0
文章推荐： PHP根据树的前序遍历和中序遍历构造树并输出后序遍历的方法
文章推荐： 用Python实现简单的人脸识别功能步骤详解
文章推荐： 一篇文章带你入门C语言数据结构:绪论
文章推荐： PHP简单实现循环链表功能示例
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com