C learning_11 （数组和在内存存储的理解、数组越界、数组作为形参）

数组的理解

数组越界

数组作为函数参数

数组的理解

数组的含义

在C语言中，用于存储多个相同类型的元素。它可以被简单地定义为包含多个元素的容器。数组中每个元素都可以通过索引来访问，索引从零开始递增。 C语言中的数组可以包含任何基本数据类型，例如整数、字符、浮点数等。要定义一个数组，需要指定数组的类型和元素的数量。

数组的创建

type_t arr_name [const_n];

type_t 是指数组的元素类型

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

例如：

int a[5];
char c[2];
double* ptr[10];

数组创建的其他几种实例情况

#include<stdio.h>
#define COUNT 10
enum Count {
	Count = 10,
};
int main()
{
	//写法一
	int count = 10;
	int arr[count];

	//写法二
	const int count = 10;
	int arr[count];

	//写法三
	int arr[COUNT];

	//写法四
	int arr[Count];
	
	return 0;
}

以上代码中包含了4种不同的数组定义方式，分别如下：

1. 使用变量定义数组大小：

```

int count = 10;

int arr[count];

```

此种方式定义数组的长度使用的是一个变量，变量count的值为10，因此定义了一个包含10个元素的数组。

但需要注意的是，在博主的vs编译器中，采用的是C90的标准（数组大小只能是常量表达式），并不支持C99的标准（引入变长数组的概念，使得数组在创建的时候可以使用变量，但是不可以被初始化），所以这样的变量长度的数组会被编译器判定错误。

而在gcc编译器环境下，它是支持C99标准的特性，就允许这样的写法。

2. 使用常量定义数组大小：

```

const int count = 10;

int arr[count];

```

此种写法只是将变量count改为了常量count，但是count还是常量，只不过它拥有了常量属性，本质还是变量，原因和第一种方法相同。

3. 使用宏定义定义数组大小：

```

#define COUNT 10

int arr[COUNT];

```

通过宏定义，我们将数组大小定义为一个常量，因此在整个程序中都可以使用宏定义的值。此种方式定义的数组大小，与使用常量定义的数组大小基本相同。

4. 使用枚举定义数组大小：

```

enum Count

{

Count = 10,

};

int arr[Count];

```

使用枚举定义数组大小与使用宏定义相似，只不过使用的是枚举类型。其中，我们定义了一个名为Count，值为10的枚举常量，然后通过Count来定义数组大小。最终，以上四种方式定义的数组类型都是相同的，都定义了一个包含10个元素的数组。

总结：数组创建，在C99标准之前，[ ]（[ ]内的值必须是整型）中要给一个常量、宏定义或者枚举常量才可以，不能使用变量。在C99标准支持了变长数组的概念，数组的大小可以使用变量指定，但是数组不能初始化。

数组的初始化

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

int arr1[5] = {1，2，3，4，5};//完全初始化
int arr2[10] = {1,2,3};//不完全初始化,剩余的元素都是0
int arr3[] = {1,2,3,4};//省略数组的大小，数组会根据初始化的内容来确定
int arr4[3] = {0};//省略数组的内容，就必须要指定数组的大小

//下面解释
char arr5[] = {'a','b','c'};
char arr6[] = "abc";

数组在创建的时候如果想不指定数组的确定的大小就得初始化。数组的元素个数根据初始化的内容来确定。

现在我们来看数组中字符数组在创建为什么有两种形式（char arr5[] 和 char arr6[ ] ），以及在内存是怎么分配的。

```

char arr5[] = {'a','b','c'};

```

这种方式就是简单的使用{ }进行初始化。

```

char arr6[] = "abc";

```

这种创建char数组的方式叫做字符串字面值初始化，可以简化char数组的定义和初始化。

由两张图我们可以得出：

第二种写法等价于：

```

char arr6[] = {'a', 'b', 'b', '\0'};

```

注意：两种写法有区别，第二种写法比第一种写法多了'\0',我们以后创建使用的时候不能混淆了。

一维数组的使用

数组访问的操作符： [ ]

下标从'0'开始

#include <stdio.h>
int main()
{
 int arr[10] = {0};//数组的不完全初始化

 //计算数组的元素个数
 int sz = sizeof(arr)/sizeof(arr[0]);

 //对数组内容赋值,数组是使用下标来访问的，下标从0开始。所以：
 int i = 0;//做下标
 for(i=0; i<10; i++)//这里写10，好不好？ -  可以清晰的看到元素的总个数
 {
     arr[i] = i;
 } 

 //输出数组的内容
 for(i=0; i<10; ++i)
 {
     printf("%d ", arr[i]);
 }
 return 0;
}

总结:

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

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

一维数组在内存中的存储

上面我们打印的是数组每个元素的内容，现在我们来打印一下数组每个元素的地址
//输出数组每个元素的地址
	for (i = 0; i < 10; ++i)
	{
		printf("[%d]==%p\n", arr[i], &arr[i]);
	}

总结：数组在内存中是连续存储的。

二维数组的含义

二维数组是一种数组类型，它可以存储具有相同数据类型的元素值，

但是以二维网格的形式存储。

例如：

二维数组由行和列组成，其中每个元素可以通过其行和列的索引来访问。通常，我们使用两个下标来访问二维数组的元素，第一个下标表示要访问的行数，第二个下标表示要访问的列数。

二维数组的创建

int arr[3][4];

char arr[3][5];

double arr[2][4]

二维数组的初始化

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

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

int arr[][4] = {{2,3},{4,5}};//二维数组如果有初始化，行可以省略，列不能省略

二维数组的使用

二维数组的使用也是通过下标的方式，行下标和列下标都从0开始。

#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("%d ", arr[i][j]);
		}
	}
	return 0;
}

二维数组在内存中的存储

//输出数组每个元素的地址
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]);
	}
}

二维数组初始化为什么可以省略行，不能省略列

二维数组是由多个一维数组按照行排列而成的，每一个一维数组被称为一行，它们在内存中是连续存放的，行与行之间是相互独立的。当我们初始化一个二维数组时，需要指定其行数和列数。

对于指定行数，我们可以采用以下两种方式：

1. 显示指定行数

```

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

```

这种方式明确指定了行数为2。

2. 隐式指定行数

```

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

```

这种方式没有指定行数，但是编译器会根据初始化中元素的个数来计算出行数，这里由于有两个一维数组，每个一维数组包含3个元素，所以行数为2。

对于指定列数，我们需要显式指定数组列数，因为在分配内存空间时，需要先知道每一行应该分配多少个元素。如果省略了列数，则编译器无法确定每一行应该分配多少个元素。因此，初始化二维数组时可以省略行数，但必须指定列数。

数组越界

数组的下标是有范围限制的。数组的下规定是从0开始的，如果数组有n个元素，最后一个元素的下标就是n-1。所以数组的下标如果小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。 C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的，所以我们在写代码时，最好自己做越界的检查。

#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\n", arr[i]);//当i等于10的时候，越界访问了
   }
 return 0;
}

        这段代码定义了一个长度为10的整型数组，并将其初始化为1到10的连续数字。然后通过循环遍历数组，依次输出数组中的元素，但是需要注意的是，在循环中判断的条件是 `i<=10`，这意味着循环将会执行11次，而数组下标从0开始，最大只能取到9。

        因此，在循环的最后一次迭代中，`i`等于10，此时访问了数组下标为10的元素，即超出了数组的范围，这个错误我们称之为数组越界访问。

        越界访问是一种常见的编程错误，它可能导致程序崩溃、产生不可预知的结果或安全隐患等问题。为了避免越界访问，我们需要在访问数组元素时，保证数组下标的合法性，即数组下标不能小于0，且不能大于等于数组长度。所以代码中应该把循环判断条件修改为 `i<10`。

数组作为函数参数

在C语言中，我们可以将数组作为函数的参数来传递。当我们将一个数组作为参数传递给函数时，实际上传递的是数组的地址。在函数中，我们可以通过传递进来的地址来访问数组中的元素，对数组进行读取、修改等操作。

数组名怎么理解

数组名通常情况下就是数组的首元素的地址。
但是有两个例外:
1.sizeof(数组名),数组名单独放在sizeof()内部,这里的数组名表示整个数组,计算的是整个数组的大小。
2.&数组名,这里的数组名表示整个数组,这里取出的是整个数组的地址。

我们来用函数作为参数写一个冒泡排序实现整形数组排序。

#include <stdio.h>
void bubble_sort(int arr[])
{
	int sz = sizeof(arr) / sizeof(arr[0]);//这样对吗？
	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,7,5,8,9,0,2,4,6 };
	bubble_sort(arr);//是否可以正常排序？
	int i = 0;
	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

        在这段代码中，定义了一个名为 `bubble_sort` 的函数，它接受一个整型数组 `arr` 作为参数。在函数内部，使用双重循环实现了冒泡排序算法，将传入的数组进行排序。

        在 `main` 函数中，定义并初始化了一个整型数组 `arr`，然后将其作为参数传递给 `bubble_sort` 函数进行排序。

        然而，这段代码存在一个问题：在 `bubble_sort` 函数中，计算数组长度的方式不确。在 C 语言中，数组作为函数参数时，我们只能传递数组的地址，也就是指向数组第一个元素的指针。因此，当 `bubble_sort` 函数被调用时，传递给它的是数组的地址，而不是数组本身的大小。因此，`sizeof(arr)` 将会返回数组指针的大小，而不是整个数组的大小。我们试着打印一下发现结果确实是4，并且程序也提示警告。

为了解决这个问题，我们可以在调用函数时将数组的长度一起传递给函数，或者在函数内部使用另一个参数来表示数组的长度。在这段代码中，我们可以在定义函数时加上一个表示数组长度的参数 `int len`，然后在调用函数时将数组的长度传递给它。

修改后的冒泡排序算法：

#include <stdio.h>
//void bubble_sort(int *arr,int sz)
void bubble_sort(int arr[],int sz)
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)//比较的趟数
	{
		int j = 0;
		int flag = 1;//表示有序
		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;
				flag = 0;//表示无序
			}
		}
		if (flag == 1)//本轮比较的过程没有元素交换
			break;
	}
}
int main()
{
	int arr[] = { 3,1,7,5,8,9,0,2,4,6 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr,sz);
	int i = 0;
	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

在代码中，用一个flag变量来表示当前的数组是否已经有序了。在每一轮比较之前，将flag值赋为1，表示当前的数组已经有序。如果在比较的过程中发现有元素需要进行交换，那么就将flag值改为0，表示当前的数组无序。在每一轮比较结束之后，检查flag的值。如果flag值还是1，说明这一轮比较过程中没有进行任何元素的交换，也就是整个数组已经有序了。此时就可以直接退出排序循环，不再进行无用的比较，从而提高排序的效率。这个优化方法能够有效地减少排序循环的次数，尤其在处理大数据量时效果更为明显。因为如果数组已经有序，那么不必再进行多余的比较操作，这样可以大大减少算法的时间复杂度。