秋刀鱼在做梦

这个屌丝很懒，什么也没留下！

热门标签

详细讲解 —— 数组（C语言初阶）

作者：秋刀鱼在做梦 | 2024-06-25 23:05:31

踩

数组

1. 一维数组。

1.1 数组的创建和初始化

数组的创建：

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

数组的创建方式：


int   arr   [常量表达式];
//int是指数组的元素类型，也可以是float，char这种类型。
//在arr[]在[]中放的是常量表达式
//在C99之前 —— arr[]中时不能用变量的，要用常量。

数组创建的实例：


char arr1[10];
float arr2[1];
double arr3[20];

数组的初始化

如果只是创建数组（不初始化），然后使用数组，编译器就会报错，因为数组的值是不知道的。

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


#include<stdio.h>
int main()
{
	//三种常见的初始化方式
	int arr1[20] = { 1,2,3 };
//这个数组的空间大小是20*4个字节，前三个元素的值为1，2，3，其他的值默认为0 —— 不完全初始化
 
	int arr2[] = { 1,2,3 };
//这个数组的初始化虽然没有给元素个数，但是C语言的语法还是支持的，元素的个数是根据{}中元素个数来给的
//{}中有几个元素，这个数组的空间大小就是多少 —— 空间大小为3*4个字节
 
	int arr3[3] = { 1,2,3 };
//完全初始化
 
	//理解下面三种数组初始化的含义
	char arr4[] = "abc";
//这个数组的空间大小为4个字节，其中存放的是a b c \0 —— 字符串后面默认有一个\0。——由“”引起的内容
//为字符串
 
	char arr5[] = { 'a', 'b', 'c' };
//这个数组的空间大小为3个字节，其中存放的是a b c
 
	char arr6[] = { 'a', 98, 'c' };
//因为数据类型为char类型的，所以98代表的是b，b的ASCII值为98
 
	return 0;
}

1.2 一维数组的使用

对于数组的使用我们之前介绍了一个操作符：

[ ] ，下标引用操作符 —— 它其实就数组访问的操作符。


#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]);   //计算数组的元素个数
    //对数组内容赋值,数组是使用下标来访问的，下标从0开始
    printf("%d\n", arr[4]);   //打印数字5；
    int i = 0;
    //利用循环打印数组的内容
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

总结:

1. 数组是使用下标来访问的，下标是从0开始。

2. 数组的大小可以通过计算得到。

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

代码：


#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;
}

结果：

结论：

从结果中我们可以看出来：随着一维数组下标的增长，元素的地址，也在有规律的递增 —— （1）数组在内存中是连续存放的 —— （2）数组中的地址是由低到高排序的

1.4 了解数组在存储中的本质

数组在内存中的本质：

（1）数组在内存中是连续存放的

（2）数组中的地址是由高到低排序的

代码举例：


//打印数组中的内容
#include<stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = arr; //定义指针变量为int类型
//普通做法
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
//利用数组在内存中是连续存放的规律
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *p);
		p++;  //指针变量+1表示，跳过一个整型空间
	}
	return 0;
}

2. 二维数组

2.1 二维数组的创建和初始化

二维数组的创建


int arr[3][4];
char arr[3][5];
double arr[2][4];

二维数组的初始化


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


//2
int arr[3][4] = { {1,2},{4,5} };


//3
int arr[][4] = { {2,3},{4,5} };
//二维数组初始化了，可以省略列数下标，但是不能省略行数下标


//4
char ch[3][4] = { "abc","bcd" };

2.2 二维数组的使用

二维数组的使用也是通过下标的方式。


#include <stdio.h>
int main()
{
   int arr[3][4] = {0};
   int i = 0;
//对arr数组初始化赋值
   for(i=0; i<3; i++)
   {
      int j = 0;
      for(j=0; j<4; j++)
      {
         arr[i][j] = i*4+j;
      }
   }
//打印arr数组的内容
   for(i=0; i<3; i++)
   {
      int j = 0;
      for(j=0; j<4; j++)
      {
         printf("%d ", arr[i][j]);
      }
   }
   return 0;
}

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

像一维数组一样，这里我们尝试打印二维数组的每个元素的内存地址


#include <stdio.h>
int main()
{
	int arr[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12,};
	int i = 0;
//打印数组arr的每一个元素的地址
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 4; j++)
		{
			printf("&arr[%d][%d] = %p\n", i, j, &arr[i][j]);
		}  //%p —— 是打印地址
	}
	return 0;
}

从上面的结果就可以看出：二维数组在内存中也是连续存储的。

也可以理解成：二维数组有三个元素，每个元素是一个一维数组

我们可以把二维数组想象成一个几行几列的数组

但是本质上的二维数组是一列的。 ———— 如上图

2.4 了解数组在存储中的本质

数组内存的本质：

（1）数组在内存中是连续存放的

（2）数组中的地址是由高到低排序的

代码举例：


#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* p = arr;
	//普通的打印方式
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 4; j++)
		{
			printf("%d ", arr[i][j]);
		}
	}
	printf("\n");
	//利用本质来打印数组
	for (i = 0; i < 12; i++)
	{
		printf("%d ", *p);
		p++;
	}
	return 0;
}

3. 数组越界

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

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

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

C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的，所以程序员写代码时，最好自己做越界的检查。

代码举例：


#include<stdio.h>
int main()
{
	int arr[5] = { 1,2,3,4,5 };
	int i = 0;
	for (i = 0; i <= 5; i++)  //其中的arr[5]越界访问了
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

从上图可知，越界访问的值是系统给的随机值。

二维数组的行和列也可能存在越界 —— 在这里就不多讲了

4. 数组作为函数参数

4.1 数组名是什么？


#include <stdio.h>
int main()
{
    int arr[10] = { 1,2,3,4,5 };
    printf("%p\n", arr);
    printf("%p\n", arr+1);
    printf("%p\n", &arr[0]);
    printf("%d\n", *arr);
    //输出结果
    return 0;
}

从上面就可以看出：数组名是首元素的地址

有两种例外的情况：数组名不是首元素的地址。

1. sizeof(数组名)，计算整个数组的大小，sizeof内部单独放一个数组名，数组名表示整个数组。

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

除此1,2两种情况之外，所有的数组名都表示数组首元素的地址。

代码演示：


#include <stdio.h>
int main()
{
    int arr[10] = { 1,2,3,4,5 };
    printf("%p\n", arr);
    printf("%p\n", &arr);
    printf("----------\n");
    printf("%p\n", arr + 1);
    printf("%p\n", &arr + 1);
    return 0;
}

从结果中我们可以看到：

arr的地址加一 —— 数组的地址跳过 4

&arr的地址加一 —— 数组的地址跳过 40。

有不同的结果是因为：&arr表示的是整个数组的地址，arr表示的是数组第一个元素的地址

4.2 冒泡排序函数的设计

冒泡排序的原理：

冒泡排序代码：


#include<stdio.h>
 
void 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 tem = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tem;
			}
		}
	}
}
 
void Print(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
 
int main()
{
	int arr[10] = { 7,8,9,4,5,6,1,2,3 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	//冒泡排序
	Sort(arr, sz);
	//打印数组的内容
	Print(arr, sz);
	return 0;
}

5. 数据实例：

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

解析 —— 以前我写过的一篇博客连接如下：

三子棋小游戏：分析并实现 —— 三子棋（井字棋）小游戏（利用C语言实现）_IT技术博主-方兴未艾的博客-CSDN博客

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

解析 —— 以前我写过的一篇博客连接如下：

扫雷小游戏：分析并实现 —— 扫雷小游戏（利用C语言实现）_结构体数组完成扫雷小游戏函数分析_IT技术博主-方兴未艾的博客-CSDN博客

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/秋刀鱼在做梦/article/detail/757657