C语言数组

1.数组是一群相同类型元素的集合。

1.1一维数组的创建方式：元素类型+数组名+数组大小(常量表达式)。

例： int arr[5];
    char arr2[6];

1.2数组的初始化

     int arr1[10] = { 1,2,3 };//不完全初始化，3后面是/0
    int arr2[] = { 1,2,3,4 };
    int arr3[5] = { 1,2,3,4,5};
    char arr4[3] = { 'a',98, 'c' };//98是b的阿斯克吗值

    char arr5[] = { 'a','b','c' };//数组大小是3个字节

    char arr6[] = "abc";//还有一个/0，数组大小是4个字节
 

1.3一维数组的使用

①数组是有下标的，数组中第一个元素的下标是0，我们可以用数组的下标访问数组里的元素。

当我们想打印出数组第六个元素使，只需用下标访问操作符，访问数组的第五个下标。

// [ ] 下标访问操作符。

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

int sz1 = sizeof(arr) //计算数组的大小

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

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

//根据上图代码可知，一维数组在内存中是连续存放的，数组随着下标的增长，地址由低到高变化。 

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

2.1二维数组的创建

 int arr1[3][4];  //表示数组为3行4列
char arr2[3][5];
double arr4[2][4]；

int arr3[ ] [ 4];   //二位数组创建时，行可以省略，列不能省略。

//和一维数组一样，二位数组第一行和第一例元素的下标为0，访问二位数组使要注意。

2.2二维数组初始化

①int arr[3][4] = {1,2,3,4}  //不完全初始化，第一行填满，其余为0；

②int arr[3][4] = {{1,2},{4,5},{5,6}}; //如果想在第一行不填满数据的情况下，将元素填入其他行，用{ }将每一行分开即可。

③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("%d ", 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("&arr[%d][%d] = %p\n", i, j,&arr[i][j]);
   }
  }
    return 0;
}

 //相邻元素之间相差4个字节，每行相差16个字节，说明二维数组在内存中的存储也是连续的

3. 数组越界

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

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

 我们创建一个整数数组arr，放入10 个元素，arr数组的下标范围是0~9；当超出第9个下标时这个数组就越界了。

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

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

4. 数组作为函数参数

4.1

往往我们在写代码的时候，会将数组作为参数传个函数，比如：我要实现一个冒泡排序。

冒泡排序的思想：两两相邻元素进行比较，如果可能的话需要交换位置。

假设在（2,4,3,5,7,1,0,9,8,6）改成升序，9 8两两进行比较，9比8大，9和8交换位置，然后9与7进行比较，9比7大，9和7交换位置，最后9与其他数比较完了，从开始8与它相邻的数字进行比较。最终变成（0 1 2 3 4 5 6 7 8 9）。

 //一趟冒泡排序能搞定一个数字

让当前待排序数组中一个元素来到最终应该出现的位置上。

数组作为函数参数的时候，传过去的是数组首元素的地址。

//冒泡排序
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 t = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = t;
			}
		}
	}


}
int main()
{
	int arr[10] = {2,4,3,5,7,1,0,9,8,6};
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}

	return 0;
}

//输出结果  0 1 2 3 4 5 6 7 8 9

 

4.2 数组名

数组名是首元素地址。（但是有例外）

例外①，sizeof内部单独放入数组名，此时数组名代表整个数组，sizeof（arr）计算的是整个数组的大小，单位是字节。

例外②，&arr，此时数组名表示整个数组，取出的是整个数组的地址。

 虽然&arr打印出来的只是首元素地址，我们给 arr、 &arr[0]、&arr都＋1；在打印他们+1后的地址，结果发现arr+1、 &arr[0]+1的地址只比原来多了4个字节，也就是一个元素大小的内存空间；而&arr+1比原先多了20 个字节，比原来多了一个数组大小的内存空间。