C语言（六） 数组

今天我们要学习一下C语言中的数组，我们先来简单的看一下一维数组和二维数组的创建以及初始化，还有他们的使用。

一维数组的创建和初始化

数组的创建

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

数组的创建方式：

type_t arr_name [const_n];
//type_t 是指数组的元素类型
//const_n 是一个常量表达式，用来指定数组的大小

数组的创建实例：

//代码1
int arr1[10];
//代码2
int count = 10;
int arr2[count];//数组时候可以正常创建？
//代码3
char arr3[10];
float arr4[1];
double arr5[20];

注意：数组的创建，[ ]中要给一个常量才可以，不可以使用变量。
数组的初始化
数组的初始化是指，在创建数组的同时给数组的内容一些合理的在初始值。

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[] = "abcdef";
....

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

但是对于下面的代码要区分，内存中应如何分配。

char arr1[] = "abc";
char arr2[3] = {'a','b','c'};
char*p = "abcdef";

一维数组的使用

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

#include <stdio.h>
int main()
{
   int arr[10] = {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]);
}

总结：

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

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

int arr[10];
int sz = sizeof(arr)/sizeof(arr[0]);

一维数组在内存中的存储

#include<stdio.h>
#include<stdlib.h>

int main()
{
	int arr[10] = { 0 };
	int i = 0;
	for (i = 0; i<sizeof(arr) / sizeof(arr[0]); ++i)
	{
		printf("&arr[%d] = %p\n", i, &arr[i]);
	}
	system("pause");
	return 0;
}



结果如下：

通过输出的结果，我们可以发现。随着数组下标的增长，元素的地址，也在有规律的递增。
由此可得出结论：数组在内存中是连续存放的。
指针的初步介绍
上面呢，我们知道了数组在内存中的存储方式。现在我们尝试一下用指针的形式访问数组。
首先呢，我们先来介绍一下指针是什么？

结论：
 1.内存中的一个每内存单元（字节）对应一个地址。
 2.在32位的平台上指针的大小事4个字节。64位平台式8个字节。所以我们在C语言中取出某个变量的地址。

int num = 10;
#//取出num的地址。
指针可以理解为一个变量，是一个专门用来存放地址的一个变量。通常我们讲的指针其实是一个指针变量。说到指针变量。我们来看一下什么是指针变量。


int *ptr = NULL;//定义一个整型的指针变量，初始化为NULL.
char *ptr = NULL;//定义一个字符的指针变量，初始化为NULL.
double *ptr = NULL;//定义一个双精度浮点数的指针变量，初始化为NULL.
当我们拿到指针的时候也要找到指针所指向的变量，这里就是沃恩学过的 * ，解引用操作符的作用了。


int num = 10;
int *p_num = #//将num的地址存放在p_num指针变量中。
*p_num = 20;//改变的其实是num这个变量的内容。
一维数组的指针访问

首先我们先来看：

#include<stdio.h>
#include<stdlib.h>

int main()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	printf("%p\n", arr);
	printf("%d\n", *arr);//这里输出什么？
	system("pause");
	return 0;
}



结果为：

  由此可见，数组的数组名其实就是数组的首元素地址。

#include<stdio.h>
#include<stdlib.h>

int main()
{
	int arr[10] = { 0 };
	int i = 0;
	for (i = 0; i<sizeof(arr) / sizeof(arr[0]); ++i)
	{
		printf("&arr[%d] = %p\n", i, &arr[i]);
		printf("%p\n", arr + i);
	}
	//int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	//printf("%p\n", arr);
	//printf("%d\n", *arr);//这里输出什么？
	system("pause");
	return 0;
}

结果为：


我们观察可发现，通过数组对数组名+整数的运算，其实就可以获取到数组每个元素的地址。
这样我们就可以使用指针来访问数组了：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int arr[10] = { 0 };
	int i = 0;
	int *p_arr = arr;
	for (i = 0; i<sizeof(arr) / sizeof(arr[0]); ++i)
	{
		*(p_arr + i) = i;
	}
	for (i = 0; i<sizeof(arr) / sizeof(arr[0]); ++i)
	{
		printf("%d\n", *(p_arr + i));
	}
	system("pause");
	return 0;
}
结果为 ：1 2 3 4 5 6 7 8 9 10



二维数组的创建和初始化

//数组创建
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}};
二维数组的使用


二维数组的使用也是通过下标的方式

#include<stdio.h>
#include<stdlib.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]);
		}
	}
	system("pause");
	return 0;
}
结果为 0 1 2 3 4 5 6 7 8 9 10 11

二维数组在内存中的存储
像一维数组一样，我们尝试打印二维数组的每一个元素

#include<stdio.h>
#include<stdlib.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]);
		}
	}
	system("pause");
	return 0;
}
结果为：



通过分析我们可以知道，二维数组也是连续存储的：


二维数组的指针访问
我们知道了一维数组的内存存储后，我们尝试用指针的方式对一维数组进行访问，现在我们学了二维数组也应该尝试一下用指针来访问二维数组。

#include <stdio.h>
int main()
{
	int arr[3][4] = { 0 };
	int *p = &arr[0][0];
	int i = 0;
	for (i = 0; i<3 * 4; i++)
	{
		p[i] = i;
	}
	for (i = 0; i<3; i++)
	{
		int j = 0;
		for (j = 0; j<4; j++)
		{
			printf("%d ", arr[i][j]);
		}
	}
	return 0;
}
有关数组的运算

那么关于数组呢，我们要学会一下运算：

比如说

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int main()
{
	一维数组
	//int a[] = { 1, 2, 3, 4 };
	//printf("%d\n", sizeof(a));//16
	//printf("%d\n", sizeof(a + 0));//4
	//printf("%d\n", sizeof(*a));//4
	//printf("%d\n", sizeof(a + 1));//4
	//printf("%d\n", sizeof(a[1]));//4
	//printf("%d\n", sizeof(&a));//4
	//printf("%d\n", sizeof(&a + 1));//4
	//printf("%d\n", sizeof(&a[0]));//4
	//printf("%d\n", sizeof(&a[0] + 1));//4
	//字符数组
	//char arr[] = { 'a', 'b', 'c', 'd', 'e', 'f' };
	//printf("%d\n", sizeof(arr));//6
	//printf("%d\n", sizeof(arr + 0));//4
	//printf("%d\n", sizeof(*arr));//1
	//printf("%d\n", sizeof(arr[1]));//1
	//printf("%d\n", sizeof(&arr));//4
	//printf("%d\n", sizeof(&arr + 1));//4
	//printf("%d\n", sizeof(&arr[0] + 1));//4
	//char *p = "abcdef";
	//printf("%d\n", sizeof(p));//4
	//printf("%d\n", sizeof(p + 1));//4
	//printf("%d\n", sizeof(*p));//1
	//printf("%d\n", sizeof(p[0]));//1
	//printf("%d\n", sizeof(&p));//4
	//printf("%d\n", sizeof(&p + 1));//4
	//printf("%d\n", sizeof(&p[0] + 1));//4
	//二维数组
	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));//48
	printf("%d\n", sizeof(a[0][0]));//4
	printf("%d\n", sizeof(a[0]));//16
	printf("%d\n", sizeof(a[0] + 1));//4
	printf("%d\n", sizeof(a + 1));//4
	printf("%d\n", sizeof(&a[0] + 1));//4
	printf("%d\n", sizeof(*a));//16
	printf("%d\n", sizeof(a[3]));//16
	system("pause");
	return 0;
}

总结：数组名代表整个数组的时候只有两种情况：

 1、sizeof（数组名），这里的数组名表示整个数组。
 2、&数组名，这列的火速组名表示整个数组。
数组作为函数参数
我们在写代码的时候，通常会作为参数传个函数，比如，我们要实现一个冒泡排序讲一个整形数组排序。
这时我们可能会这么设计函数：

	void bubble_sort(int arr[])
	{
		int sz = sizeof(arr) / sizeof(arr[0]);//这样对吗？
		...
	}
获取数组的元素个数，这样设计函数是错误的。

数组作为函数参数的时候，不会把整个数组传递过去。实际上只是把数组的首元素地址传递过去了。所以即使在函数参数部分写成了数组的形式：  int  arr[ ]表示的依然是一个指针，int *arr 。
上面的代码中sz的最后值应该是1，而不是数组元素的个数。