C语言一维数组的用法

1.数组的相关概念

（1）数组属于构造类型。

（2）数组的每个元素的类型一致，由定义数组时的类型决定。

（3）数组中的每个元素在内存中都是连续的。

（4）数组分类：一维数组、二维数组、多维数组。

2.一维数组

（1）一维数组只有一个下标，此下标称为元素的下标。

（2）数组的下标从0开始，及第0个下标的元素称为第0个元素。

（3）数组在内存中分配的空间是连续的。

3.定义一维数组

（1）定义一维数组的格式：

        数据类型    数组名[ ] = { 元素1，元素2， 元素3，......}；

        例：int   array[ 5] = {10, 20, 30, 40, 50};

(2)访问数据某个元素的值

        数组名[元素下标]；

        1>数组元素的下标从0开始

        2>访问数组元素时只能一个元素一个元素的访问

（3）修改数组某个元素的值

        数组名[元素下标] = 值；

4.一维数组案例

#include <stdio.h>

// int arr[] : 需要传递一个int类型的数组名
void print_array(int arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("arr[%d] = %d\n", i, arr[i]);
	}

	puts("---------------------------");
}


int main(int argc, const char *argv[])
{
	// 1. 定义数组时，对数组的每个元素进行初始化
	// 数组的每个元素都是int类型，
	// 数组的长度是5，数组元素下标为0-4
	// 数组占用内存空间的大小为：20字节
	int arr1[5] = {111,222,333,444,555};
	
	// 遍历数组每个元素的值
	for (int i = 0; i < 5; i++)
	{
		printf("arr[%d] = %d\n", i, arr1[i]);
	}

	printf("------------------------\n");
	
	// 2. 定义数组时，只对部分元素初始化，其他元素默认初始化为0
	int arr2[5] = {666,777};	// 对第0和第1个元素初始化，其他元素初始化为0

	// 遍历数组每个元素的值
	for (int i = 0; i < 5; i++)
	{
		printf("arr2[%d] = %d\n", i, arr2[i]);
	}

	printf("------------------------\n");
	
	// 3. 定义数组时，将每个数组元素都初始化为0
	int arr3[5] = {0};
	// 遍历数组每个元素的值
	for (int i = 0; i < 5; i++)
	{
		printf("arr3[%d] = %d\n", i, arr3[i]);
	}

	printf("------------------------\n");
	
	// 4. 先定义数组，然后在依次对每个元素进行初始化
	int arr4[5];	// 如果没有初始化，数组的每个元素都是随机值 
	printf("打印初始化之前数组每个元素的值 ：\n");
	print_array(arr4, 5);
	
	// 对数组的每个元素进行初始化 
	arr4[0] = 100;
	arr4[1] = 200;
	arr4[2] = 300;
	arr4[3] = 400;
	arr4[4] = 500;
	printf("初始化数组每个元素的值之后，数组元素的值:\n");
	print_array(arr4, 5);
	

	// 5. 通过终端输入的方式对数组的每个元素进行初始化
	int arr5[5] = {0};
	for (int i = 0; i < 5; i++)
	{
		// &arr5[i] : 取对应数组元素的地址
		scanf("%d", &arr5[i]);
	}
	print_array(arr5, 5);
	
	// 6. 定义数组时，不指定数组的长度，由初始化数组元素的个数，决定数组的长度
	// 如果不指定数组的长度，定义数组时，必须对数组进行初始化
	int arr6[] = {100,200,300,400,500,600};	// 数组元素个数为6
	
	print_array(arr6, 6);


	// 7. 定义数组并初始化数组错误的方式
	int arr7[5];
	// 数组一旦定义完成，对数组的元素只能一个一个的进行访问
	arr7 = {111,222,333,444,555};		// 错误
	

	int arr8[5] = {1,2,3,4,5};
	// 数组名表示数组的首地址，数组名是一个常量，不可以被修改
	//int arr9[5] = arr8;	// 错误
	//arr9 = arr8;		// 错误

	//int arr10[];	// 错误
	// 定义数组时，如果不指定数组的长度时，必须定义数组的同时进行初始化，
	// 不可以先定义数组，后进行初始化
	//arr10[0] = 10;
	//arr10[1] = 20;

	return 0;
}

5.一维数组使用注意事项

（1）数组每个元素在内存中是连续的

（2）求数组在内存中占用空间的大小sizeof(数组名)

  (3)   求数组元素的个数（数组的长度） = sizeof(数组名)  /  sizeof(数组元素类型)

  (4)    在对数组元素进行访问时，编译器不会进行数组的越界的检查，因此要程序员在访问数组元元素时，不要进行越界访问。

（5）数组名是一个常量，表示数组的首地址，和数组的第0个元素的地址一致。

（6）&数组名[i] 数组的第i个元素的地址

        &数组名[i] + 1 数组的第i个元素的地址加1， 地址加1，加的是数组类型的大小（int  char ...）

（7）数组名[i]   数组的第i个元素的值

        数组名[i] + 1  数组的第i个元素的值加1

（8）数组名    表示数组分配内存空间的首地址

          数组名  + i     数组名加 + i  地址向后偏移（i * 数据类型）大小的空间

#include <stdio.h>

int main(int argc, const char *argv[])
{
	// 1. 数组每个元素在内存中是连续的
	short  arr1[5] = {111,222,333,444,555};
	for (int i = 0; i < 5; i++)
	{
		// 打印数组每个元素的地址  
		// &arr1[i] : 数组的第i个元素的地址
		// %p : 使用16进制打印地址
		printf("&arr1[%d] = %p\n", i, &arr1[i]);
	}

	// 2. 求数组在内存中占用空间的大小  sizeof(数组名)
	printf("数组占用内存大小 = %ld\n", sizeof(arr1));

	// 3. 求数组元素的个数(数组的长度)  sizeof(数组名) / sizeof(数组元素类型)
	printf("数组长度 = %ld\n", sizeof(arr1) / sizeof(short));
	
	// 4. 在对数组元素进行访问时，编译器不会进行数组越界的检查
	// 	因此要求程序员在访问数组元素时，不要进行越界访问。
	arr1[1000] = 10000;		// 数组越界赋值
	printf("arr1[1000] = %d\n", arr1[1000]);


	// 5. 数组名相关的验证
	// 5.1 数组名是一个常量，表示数组的首地址，和数组的第0个元素的地址一致
	printf("数组首地址 = %p\n", arr1);
	printf("数组第0个元素的地址 = %p\n", &arr1[0]);
	
	short arr2[5];
	// arr2 = arr1;		// 给arr2数组名赋值，错误的，数组名是一个常量，不可以被修改
	
	// 5.2 数组名[i] : 数组的第i个元素的值 
	// 		数组名[i] + 1 : 数组的第i个元素的值加1 
	printf("arr1[3] = %d\n", arr1[3]);
	printf("arr1[3] + 1 = %d\n", arr1[3] + 1);
	
	// 5.3 &数组名[i] : 数组的第i个元素的地址 
	// 		&数组名[i] + 1 : 数组的第i个元素的地址加1 ， 
	// 		地址加1，加数组类型大小
	printf("&arr1[2] = %p\n", &arr1[2]);
	printf("&arr1[2] + 1 = %p\n", &arr1[2] + 1);

	// 5.4 数组名表示数组的首地址，数组名是一个常量 
	// 	数组名 ： 表示数组分配内存空间的首地址
	// 	数组名 + i ： 数组名+i，地址向后偏移(i * 数据类型)大小的空间
	printf("arr1 = %p\n", arr1);
	printf("arr1 + 1 = %p\n", arr1 + 1);

	return 0;
}