数组

首先，我们学习一样东西一定要知道它的用途，我们为什么要学习数组，因为它可以解决大量同类型数据的储存和使用问题

一维数组

什么是一维数组

1. 连续为多个变量分配存储空间
2. 数组内所有变量的数据类型相同
3. 所有变量所占的字节数相同

数组定义和赋值

int a[3] = {1,2,3};

注意：
a是数组名，其中数组名a代表该数组中首个元素a[0]的地址。3是数组元素的个数，1，2，3是分别用来给a[0]，a[1]，a[2]赋初值的,而［］里面的东西叫下标

特别注意的：

int a[3] = {1,2,3};
//正确
 
int a[3];
a[3] = {1,2,3};
//错误 

只有在定义数组的时候，才能对整体赋值
要想先定义再赋值，则需要一个个赋值，如：

int a[3];
a[0] = 1;
a[1] = 2;
a[2] = 3;
//正确 

数组使用问题

关于初始化

（1）完全初始化

int a[5]=｛1，2，3，4，5｝;

（2）不完全初始化

int a[5]=｛1，2，3｝;

默认未初始化的元素的值为0

验证小例子：

#include <stdio.h>
int main (void)
{
	int a[5] = {1, 2, 3};
	printf ("a[4] = %d", a[4]);
}
//结果： a[4] = 0

小习题

（1）题目：如何将数组a中元素的值一一复制给数组b
答案：

# include <stdio.h>
int main (void)
{
	int i;
	int a[4] = {0,1,2,3};
	int b[4];
	for (i = 0; i < 4; i++)
	{
		b[i] = a[i];
	}
}

（2）题目：如何输出一维数组
答案：

# include <stdio.h>
int main (void)
{
	int i;
	int a[4] = {0,1,2,3};
    for (i = 0; i < 4; i++)
    {
    	printf ("a[%d] = %d\n",i, a[i]);
	}
}
/*结果： 
a[0] = 0
a[1] = 1
a[2] = 2
a[3] = 3
*/ 

二维数组

int a[2][3]；
该数组有六个元素，可用两行三列来表示，他们分别为
a[0][0] ， a[0][1]， a[0][2]
a[1][0] ， a[1][1] ， a[1][2]

小习题

题目：如何输出二维数组
答案：

#include <stdio.h>
int main (void)
{
	int a[2][3] = {0,1,2,3,4,5};
	int i, j;
	for (i = 0; i < 2; i++)
	{
		for (j = 0; j < 3; j++)
		{
			printf ("%-5d", a[i][j]);
		}
	}
}
//结果： 0    1    2    3    4    5

-使得输出的数左对齐，5使得输出的每个数之间差五个空格数量

多维数组

n维数组可以看作是一个1维数组，它所包含的每个元素都是n-1维的数组

例如：int a[3][4][5]；
该数组可以看作是含有三个元素的1维数组，而每个元素又包含4行5列的二维数组

传统数组（也叫静态数组）

传统数组的缺点：
1.数组的长度必须事先确定，只能定义为常整数，不能是变量
2.数组的长度一旦定义，就不能再更改
3.传统形式定义的数组，程序员无法手动释放内存，只有当函数运行完毕后，才能由系统自动释放数组的内存

动态数组

动态数组很好解决了传统数组的缺陷
动态的构造一维数组需要用到malloc函数

malloc函数的简单介绍

malloc函数的作用：让系统为本程序分配字节，并返回首个字节的地址

注意：
1.使用malloc函数要添加malloc.h头文件
2.malloc函数的形参只有一个，而且必须是整数，该整数表示要分配的字节数

#include <malloc.h>

int main (void)
{
	int i;
//i变量所占内存是静态分配的
    int* p = (int*) malloc (sizeof (int));
//sizeof(数据类型)或sizeof(变量名),可以返回该数据类型或该变量所占的字节数
//malloc (sizeof (int))是向系统申请分配大小为4的内存地址
//(int*)是强制类型转换，将这个地址转化为int*类型
//p变量所占内存是静态分配的，而它所指向的内存是动态分配的
    free (p);
//把p所指向的内存给释放掉，而p本身的内存是静态分配的，只能由系统自动释放 
}

动态的构造一维数组

# include <stdio.h>
# include <malloc.h>
 
int main (void)
{
	int len;
	printf ("请输入数组的长度: ");
    scanf ("%d", &len);
    int * parr = (int *) malloc (4 * len);
//这样动态的构造了一维数组，该数组类似于静态数组int parr[len];
}

动态内存和静态内存的比较

动态内存是由程序员手动分配和释放的，是在堆中分配的
静态内存是由系统自动分配和释放的，是在栈中分配的