C语言初识数组

这篇博客主要讲述的是内容是

一维数组的创建和初始化                                                        二位数组的使用

一维数组的使用                                                                       二位数组在内存的中存储

一维数组在内存中的存储                                                         数组越界

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

数组的概念:

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

typed_int  arr_name [n];

typed_int是数组元素的类型

arr_name是数组名

n是数组元素

1.1一维数组的创建

数组的初始化
int arr1 [10];

char arr1[10];
float arr2[1];
double arr5[2];

有人会问了，数组的创建可不可以用变量创建

在C99标准之前数组的创建必须是常量不能使用变量

#include<stdio.h>

int main()
{

	int  n = 10;
	int arr[n] = { 1,2,3,4,5,6,7,8,9,10 }; //数组的初始化
	printf("%d ", arr[n]);
	
	return 0;

}

数组创建在C99标准之前，[ ]中要给一个常量才可以，不能使用变量

在C99标准支持了变长数组的概念，数组的大小可以使用变量指定，但是数组不能初始化

个人建议在创建数组时，能用常量还是常量，我们大部分使用数组都是常量定义很少使用变量定义

1.2 一维数组的初始化

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

int arr1[4] = {1 ,2 ,3}; //不完全初始化

不完全初始化，剩余的初始化为0

int arr2[ ] = {1, 2, 3, 4}; //不指定元素大小

数组创建的时候如果不想指定数组的确定大小就得初始化。

数组的元素个数根据初始化的内容来确定

char arr3[3] = {'a' , 98 , 'c'}; //字符类型

字符类型结尾是随机值

1.3一维数组的使用

对于数组的使用我们之前介绍了一个操作符：[ ] 下标引用操作符，就是数组访问的操作符

#include<stdio.h>

int main()
{

	int arr[10] = { 0 }; //数组不完全初始化
	int sz = sizeof(arr) / sizeof(arr[0]);

	int i = 0;
	for (i = 0; i < 10; i++)
	{
		arr[i] = i;
	}

	for (i = 0; i < 10; i++)
	{
		printf("%d ", i);
	}


	return 0;
}

不知道sizeof是什么意思可以去看前面的章节

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

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

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

#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("%p\n", &arr[i]);
	}

	return 0;
}

可以看到睡着数组下标的增长，元素的地址也再有规律的递增，从之前的4递增到8由低到高

数组在内存中是连续存放的

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

2.1 二维数组的创建

int arr[3][4]; //整型
char arr[3][4]; //字符类型
double arr[2][4] //双精度浮点型

2.2 二维数组的初始化

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

二维数组如果有初始化，行可以省略，列不能省略

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

2.3 二维数组的使用

#include<stdio.h>

int main()
{

	int arr[3][4] = { 0 };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int  j = 0;
		for (j = 0; j < 4; j++)
		{
			arr[i][j] = i * 4+ j;
		}
	}
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 4; j++)
		{
			printf("%-2d ", arr[i][j]);
		}
	}

	return 0;
}

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

#include<stdio.h>

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


	return 0;
}

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

三.数组越界

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

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

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

C语言本身是不做数组下标的越界访问，编译器也不一定报错，但是编译器不会报错，并不意味着程序就是正确的

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\n", arr[i]);
	}

	return 0;
}

二维数组的行和列也可能存在越界

四. 数组作为函数参数

4.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 - 1 - i; 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,5,9,2,4,7,6,8,0 }; //数组
	//排序 - 升序
	//冒泡排序
	int sz = sizeof(arr) / sizeof(arr[0]); //计算元素个数

	bubble_sort(arr, sz);//arr是数组首元素的地址

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

	return 0;
}

4.2数组名

int main()
{
	int arr[10] = { 1,2,3,4,5 };
	printf("%p\n", arr);
	printf("%p\n", &arr[0]);
	printf("%d\n", *arr);


	return 0;
}

可以发现地址都是相同的

数组名是数组首元素的地址

还有2个例外：sizeof   &

int main()
{


	int arr[10] = { 0 };
	printf("%d\n", sizeof(arr));
	
	return 0;
}

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

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