C语言基础：006 C基础语法- 数组详解-优快云博客

本文链接：https://blog.youkuaiyun.com/changlif/article/details/125103191

本文详细介绍了C语言中一维数组的创建、初始化方法，包括常量定义数组、初始化后的元素个数确定，以及数组下标访问和内存布局。还涉及二维数组的基础概念和示例，同时讨论了数组越界问题及数组作为函数参数的应用，如冒泡排序算法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一维数组的创建和初始化

数组的创建

数组创建
type_t arr_name [const_n];

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

//const_n 是一个常量表达式
1. 注：
  数组创建，在 C99 标准之前， [] 中要给一个常量才可以，不能使用变量。在 C99 标准支持了变长数组的概念。

code实例：数组创建

#include <stdio.h>

int main()
{
	//代码1
	int arr1[10];   // 正确
	//代码2
	int count = 10;
	int arr2[count]; // 错误：数组时候不可以正常创建，错误信息：表达式必须含有常量值
	//代码3
	char arr3[10];  // 正确
	float arr4[1];  // 正确
	double arr5[20]; // 正确
}

数组的初始化

数组的初始化是指，在创建数组的同时给数组的内容一些合理初始值（初始化）。
数组在创建的时候如果想不指定数组的确定的大小就得初始化。数组的元素个数根据初始化的内容来确定。

code实例：数组的初始化

#include <stdio.h>

int main()
{
	int arr1[10] = { 1,2,3 };
	int arr2[] = { 1,2,3,4 };
	int arr3[5] = { 1,2,3,4,5 };
	char arr4[3] = { 'a',98, 'c' };
	char arr5[] = { 'a','b','c' };
	char arr6[] = "abc";
	char arr7[] = "abcdef";
	printf("数组arr1元素个数 = %d, strlen(arr1) = %d\n", sizeof(arr1) / sizeof(arr1[0]), strlen(arr1)); // 数组arr1元素个数 = 10, strlen(arr1) = 1
	printf("数组arr2元素个数) = %d, strlen(arr2) = %d\n", sizeof(arr2) / sizeof(arr2[0]), strlen(arr2));// 数组arr2元素个数 = 4, strlen(arr2) = 1
	printf("数组arr3元素个数 = %d, strlen(arr3) = %d\n", sizeof(arr3) / sizeof(arr3[0]), strlen(arr3)); // 数组arr3元素个数 = 5, strlen(arr3) = 1
	printf("数组arr4元素个数 = %d, strlen(arr4) = %d\n", sizeof(arr4) / sizeof(arr4[0]), strlen(arr4)); // 数组arr4元素个数 = 3, strlen(arr4) = 67
	printf("数组arr5元素个数 = %d, strlen(arr5) = %d\n", sizeof(arr5) / sizeof(arr5[0]), strlen(arr5)); // 数组arr5元素个数 = 3, strlen(arr5) = 35
	printf("数组arr6元素个数 = %d, strlen(arr6) = %d\n", sizeof(arr6) / sizeof(arr6[0]), strlen(arr6)); // 数组arr6元素个数 = 4, strlen(arr6) = 3
	printf("数组arr7元素个数 = %d, strlen(arr7) = %d\n", sizeof(arr7) / sizeof(arr7[0]), strlen(arr7)); // 数组arr7元素个数 = 7, strlen(arr7) = 6
}

一维数组的使用
1. 对于数组的使用我们之前介绍了一个操作符： [] ，下标引用操作符。它其实就数组访问的操作符。
2. 总结
  1. 数组是使用下标来访问的，下标是从0开始。
    
    数组的大小可以通过计算得到。
    code实例：求数组的大小
    int arr[10]; int sz = sizeof(arr)/sizeof(arr[0]);

一维数组在内存中的存储

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

code示例：取出每一个元素在数组中的位置

#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]); // 打印每个元素在内存中的位置
	}
	/*
	* &arr[0] = 000000D63E60F518
	* &arr[1] = 000000D63E60F51C
	* &arr[2] = 000000D63E60F520
	* &arr[3] = 000000D63E60F524
	* &arr[4] = 000000D63E60F528
	* &arr[5] = 000000D63E60F52C
	* &arr[6] = 000000D63E60F530
	* &arr[7] = 000000D63E60F534
	* &arr[8] = 000000D63E60F538
	* &arr[9] = 000000D63E60F53C
*/
	return 0;
}

二维数组的创建和初始化

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

二维数组的使用

code示例

#include <stdio.h>
int main()
{
	//1. 二维数组创建
	int arr1[3][4];
	char arr2[3][5];
	double arr3[2][4];
	//2. 二维数组初始化
	int arr4[3][4] = { 1,2,3,4 };
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			// 3. 二维数组的使用: 通过下标的方式。
			printf("arr4[%d][%d] = %d ",i, j, arr4[i][j]); // 1 2 3 4 0 0 0 0 0 0 0 0
		}
	}
	int arr5[3][4] = { {1,2},{4,5} };
	int arr6[][4] = { {2,3},{4,5} };//二维数组如果有初始化，行可以省略，列不能省略
	return 0;
}

二维数组在内存中的存储
1. 二维数组在内存中也是连续存储的。

数据越界
1. 所以数组的下标如果小于 0 ，或者大于 n - 1，就是数组越界访问了，超出了数组合法空间的访问。 C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的。
2. code示例
```
#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	for (i = 0; i <= 10; i++)
	{
		printf("%d ", arr[i]); // 1 2 3 4 5 6 7 8 9 10 -858993460
		//当i等于10的时候，越界访问了
	}
	return 0;
}
```

数组作为函数的参数

冒泡排序

code示例：

//方法1：
#include <stdio.h>
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];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
int main()
{
	int arr[] = { 3,1,7,5,8,9,0,2,4,6 };
	printf("%p\n", arr);     // 输出数组首地址：00000073897FFB58
	printf("%p\n", &arr[0]); // 输出数组第一个元素的地址：00000073897FFB58
	printf("%d\n", *arr);    // 输出第一个元素：3
	printf("%d\n", sizeof(arr)); // 40
	printf("%d\n", sizeof(arr) / sizeof(arr[0])); // 10

	int sz = sizeof(arr) / sizeof(arr[0]); // 数组的大小：10
	bubble_sort(arr, sz);//是否可以正常排序？
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}