数组
知识重点：
1、一维数组的创建和初始化
2、一维数组的使用
3、一维数组在内存中的存储
4、指针的初步介绍
5、一维数组的指针访问
6、二维数组的创建和初始化
7、二维数组的使用
8、二维数组在内存中的存储
正文
一、一维数组的创建和初始化
1、数组的创建：
数组：是一组相同类型元素的集合
数组的创建方式：
type_t arr_name [const_n];
//type_t 是指数组的元素类型
//const_n 是一个常量表达式用来指定数组的大小
数组创建实例：
//代码1：
int arr1[10];错误示范：
//代码2：
int coumt = 10;
int arr2[count]注：
数组创建时[ ]中要给一个常量才可以，不能使用变量
2、数组的初始化
数组的初始化是指，在创建数组的同时给数组的内容一些合理的值，例如：
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[] = "abcdef";数组在创建的时候如果不想指定数组的大小就要初始化，数组的元素个数根据初始化的内容来确定
但是对于下面的代码要注意区分其在内存中的分配：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
char arr1[] = "abc";
char arr2[5] = {'a', 'b', 'c', '\0'};
char *p = "abcdef";
char arr3[3] = {'a', 'b', 'c'};
int i = 0, j = 0, k = 0, l = 0;
i = strlen (arr1);
j = strlen (arr2);
k = strlen (p);
l = strlen (arr3);
printf ("%d %d %d %d\n",i, j, k, l);
system ("pause");
return 0;
}
/*
运行结果：
3 3 6 15
请按任意键继续. . .
*/注意：上面代码中的 char arr3[3] = {‘a’, ‘b’, ‘c’};之所以会出现运行结果是15，是因为数组越界了，像这种字符数组最后必须多留一个给’\0’标识数组结束。
二、一维数组的使用
对于数组的使用：之前在操作符知识总结中也提到一个操作符 :[ ],下标引用操作符，它其实就是数组访问的操作符。代码如下：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
int arr[10] = {0};//数组的不完全初始化
//对数组进行复制，数组是通过下标来访问的，下标从0开始，所以：
int i = 0; //做下标
for(i=0; i<10; ++i)
{
arr[i] = i;
}
for (i=0; i<10; ++i) //输出数组内容
{
printf ("%d ",arr[i]);
}
system ("pause");
return 0;
}
/*
运行结果：
0 1 2 3 4 5 6 7 8 9 请按任意键继续. . .
*/总结：
（1）数组是使用下标来访问的，下标从0开始
（2）数组的大小可通过计算得到,代码如下：
int arr[10] = {0};
int sz = sizeof (arr)/sizeof (arr[0]);三、一维数组在内存中的存储
通过下面一段代码来看以为数组在内存中的存储
#include <stdio.h>
#include <stdlib.h>
#include <string.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;
}
/*
运行结果：
&arr[0] = 00AFFEA4
&arr[1] = 00AFFEA8
&arr[2] = 00AFFEAC
&arr[3] = 00AFFEB0
&arr[4] = 00AFFEB4
&arr[5] = 00AFFEB8
&arr[6] = 00AFFEBC
&arr[7] = 00AFFEC0
&arr[8] = 00AFFEC4
&arr[9] = 00AFFEC8
请按任意键继续. . .
*/从输出的结果可以看出，随着数组下标的增长，元素的地址也在有规律的递增，由此可以得出结论：数组在内存中是连续存放的、如下图：
四、指针的初步介绍
上面我们已经知道了数组在内存中的存储方式，现在可以尝试使用指正的形式访问数组，首先使用一下指针。
为了很好的管理内存，我们首先对内存进行一个详细的编址。
结论：
（1）内存中的每个内存单元（字节）对应每个地址。
（2）在32位平台上指针大小是4个字节，在64位平台上是8个字节，所以我们在C语言中提取某个变量的地址：
int n = 10;
&n;//取出n的地址指针可以理解为一个变量，是一个专门用来存放地址的变量。
通常我们将的指针其实是一个指针变量。
接下来看看指针变量的定义：
int *ptr = NULL;//定义一个整形指针变量，初始化为NULL
char *ptr = NULL;//定义一个字符型指针变量，初始化为NULL
double *ptr = NULL;//定义一个双精度浮点数指针变量，初始化为NULL
当我们拿到一个指针时也要能找到指针所指向的变量，其中 * 是解引用操作符。
int n = 10;
int *p_n = &n;将num的地址存放在p_n指针变量中。
*p_n = 20;//改变的其实是n这个变量的内容。五、一维数组的指针访问
首先我们先看这一段代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.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;
}
/*
运行结果：
0053FC58
1
请按任意键继续. . .
*/由此可见：数组的数组名其实就是首元素的地址
在看下面的代码：
#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\t", i, &arr[i]);
printf ("%p\n",arr+i);
}
system ("pause");
return 0;
}
/*
运行结果：
&arr[0] = 00CFF964 00CFF964
&arr[1] = 00CFF968 00CFF968
&arr[2] = 00CFF96C 00CFF96C
&arr[3] = 00CFF970 00CFF970
&arr[4] = 00CFF974 00CFF974
&arr[5] = 00CFF978 00CFF978
&arr[6] = 00CFF97C 00CFF97C
&arr[7] = 00CFF980 00CFF980
&arr[8] = 00CFF984 00CFF984
&arr[9] = 00CFF988 00CFF988
请按任意键继续. . .
*/由此可见：通过数组名加整数的运算就可以得到数组的每个元素的地址
* 因此我们就可以用指针来访问数组了：
#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 ",*(p_arr+i));
}
system ("pause");
return 0;
}
/*
运行结果：
0 1 2 3 4 5 6 7 8 9 请按任意键继续. . .
*/六、二维数组的创建和初始化
1、二维数组的创建和初始化
//二维数组的创建
int arr1[3][4];
char arr2[3][5];
double arr3[2][4]; //二维数组的初始化
int arr1[3][4] = {1, 2, 3, 4};
int arr2[3][4] = {{1, 2}, {4, 5}};
int arr2[][4] = {{3, 2}, {4, 5}};七、二维数组的使用
二维数组的使用也是通过下标的方式
#include <stdio.h>
#include <stdlib.h>
int main()
{
int arr[3][4] = {0};
int i = 0, j = 0;
for (i=0; i<3; i++)
{
for(j=0; j<4; ++j)
{
arr[i][j] = i*4+j;
}
}
for (i=0; i<3; i++)
{
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] = {0};
int i = 0, j = 0;
for (i=0; i<3; i++)
{
for(j=0; j<4; ++j)
{
printf("&arr[%d][%d] = %p\n",i, j, &arr[i][j]);
}
}
system ("pause");
return 0;
}
/*
运行结果：
&arr[0][0] = 0073FDCC
&arr[0][1] = 0073FDD0
&arr[0][2] = 0073FDD4
&arr[0][3] = 0073FDD8
&arr[1][0] = 0073FDDC
&arr[1][1] = 0073FDE0
&arr[1][2] = 0073FDE4
&arr[1][3] = 0073FDE8
&arr[2][0] = 0073FDEC
&arr[2][1] = 0073FDF0
&arr[2][2] = 0073FDF4
&arr[2][3] = 0073FDF8
请按任意键继续. . .
*/
