1. 什么是数组

数组，从字面上看，就是一组数据的意思，没错，数组就是用来存储一组数据的

2. 数组的特点

只能存放一种类型的数据，比如int类型的数组、float类型的数组

里面存放的数据称为“元素”

3. 定义

声明数组的类型

声明数组的元素个数（需要多少存储空间）

4. 格式

元素类型 数组名[元素个数];

比如：int ages[3];

5. 简单使用

简单初始化：int ages[5] = {19, 19, 20, 21, 25};

元素有顺序之分，每个元素都有一个唯一的下标（索引），从0开始

数组元素的访问：a[i]

6. 初始化

初始化方式

int a[3] = {10, 9, 6};

int a[3] = {10,9};

int a[] = {11, 7, 6};

int a[4] = {[1]=11,[0] = 7};

常见错误

int a[];

int[4] a;

int a[b];

a = {10, 11};

a[4] = {10,9,8,5};

7. 内存分析

数组存储空间的大小

存储空间的划分（内存的分配是从高地址到低地址进行的，但一个数组内部元素又是从低到高进行的）

数组名的作用，查看元素地址

数组越界的注意

8. 其他使用

数组与函数参数

数组元素作为函数参数

数组作为函数参数（sizeof注意）

遍历数组元素

两种方式遍历（while循环和for循环）

遍历元素值和元素地址

字符数组的使用

9.代码

 1 #include <stdio.h>
 2 
 3 int main()
 4 {
 5     // 使用注意
 6     // 都是正确写法
 7     //int ages[5] = {10 , 11, 12, 67, 56};
 8     //int ages[5] = {10, 11};
 9     //int ages[5] = {[3] = 10, [4] = 11};
10     //int ages[] = {10, 11, 14};
11     
12     // 错误写法
13     // int ages[];
14     
15     // 错误写法
16     /* 只能在定义数组的同时进行初始化
17     int ages[5];
18     ages = {10, 11, 12, 14};
19     */
20     
21     // 正确写法
22     // int ages['A'-50] = {10, 11, 12, 14, 16};
23     //int size = sizeof(ages);
24     //PRintf("%d\n", size);
25     
26     // 正确写法
27     /*
28     int count = 5;
29     int ages[count];
30     ages[0] = 10;
31     ages[1] = 11;
32     ages[2] = 18;
33     */
34     
35     //printf();
36     // 错误写法
37     // 如果想再定义数组的同事进行初始化，数组元素个数必须是常量，或者不写
38     //int ages[count] = {10, 11, 12};
39     
40     
41     int ages[] = {10, 11, 12, 78};
42     
43     // 计算数组元素的个数
44     int count = sizeof(ages)/sizeof(int);
45     
46     for (int i = 0; i<count; i++)
47     {
48         printf("ages[%d]=%d\n", i, ages[i]);
49     }
50     
51     return 0;
52 }
53 
54 // 数组的基本使用
55 void arrayUse()
56 {
57     // 数组的定义格式： 类型 数组名[元素个数];
58     int ages[5] = {19, 29, 28, 27, 26};
59     // 19 19 28 27 26]
60     ages[1] = 29;
61     
62     /*
63      ages[0] = 19;
64      ages[1] = 19;
65      ages[2] = 28;
66      ages[3] = 27;
67      ages[4] = 26;
68      */
69     
70     /*
71      遍历：按顺序查看数组的每一个元素
72      */
73     for (int i = 0; i<5; i++)
74     {
75         printf("ages[%d]=%d\n", i, ages[i]);
76     }
77 }

数组的内存储存细节

 1 #include <stdio.h>
 2 
 3 /*
 4  提示用户输入5个学生的成绩，算出平均分并且输出
 5  */
 6 
 7 int main()
 8 {
 9     
10     
11     // 1.定义一个数组来存储成绩
12     int scores[5];
13     
14     // 2.提示输入成绩
15     // 用来存储总分
16     int sum = 0;
17     for (int i = 0; i<5; i++) {
18         // 2.1 提示输入某个学生的成绩
19         printf("请输入第%d个学生的成绩:\n", i + 1);
20         // 2.2 存储当前学生的成绩
21         scanf("%d", &scores[i]);
22         // 2.3 累加成绩
23         sum += scores[i];
24     }
25     
26     // 3.计算平均分，并且输出
27     printf("平均分是%f\n", sum/5.0);
28     return 0;
29 }
30 
31 
32 void test1()
33 {
34     // 1.定义一个数组来存储成绩
35     int scores[5];
36     
37     // 2.提示输入成绩
38     printf("请输入第1个学生的成绩:\n");
39     scanf("%d", &scores[0]);
40     
41     printf("请输入第2个学生的成绩:\n");
42     scanf("%d", &scores[1]);
43     
44     printf("请输入第3个学生的成绩:\n");
45     scanf("%d", &scores[2]);
46     
47     printf("请输入第4个学生的成绩:\n");
48     scanf("%d", &scores[3]);
49     
50     printf("请输入第5个学生的成绩:\n");
51     scanf("%d", &scores[4]);
52     
53     // 3.计算平均分，并且输出
54     int sum = 0;
55     for (int i = 0 ; i<5; i++) {
56         sum += scores[i];
57     }
58     printf("平均分是%f\n", sum/5.0);
59 }
60 
61 void test()
62 {
63     /*
64      char cs[5]= {'a', 'A', 'D', 'e', 'f'};
65      
66      printf("%p\n", cs);
67      
68      for (int i = 0; i<5; i++) {
69      printf("cs[%d]的地址是:%p\n", i, &cs[i]);
70      }*/
71     
72     int ages[3]= {10 , 19, 18};
73     
74     printf("%p\n", ages);
75     
76     for (int i = 0; i<3; i++) {
77         printf("ages[%d]的地址是:%p\n", i, &ages[i]);
78     }
79 }

数组和函数

 1 #include <stdio.h>
 2 
 3 // 数组作为函数参数，可以省略元素个数
 4 // 数组作为函数参数，传递是整个数组的地址，修改函数形参数组元素的值，会影响到外面的实参数组
 5 
 6 void change(int array[])
 7 {
 8     //printf("array==%p\n", array);
 9     
10     array[0] = 100;
11 }
12 
13 void change2(int n)
14 {
15     n = 100;
16 }
17 
18 int main()
19 {
20     int ages[6] = {10, 11, 10, 11, 10, 11};
21     
22     //printf("ages==%p\n", ages);
23     
24     change(ages);
25     
26     //change2(ages[0]);
27     
28     printf("%d\n", ages[0]);
29     return 0;
30 }

练习

 1 /*
 2 
 3 设计一个函数，找出整型数组元素的最大值
 4 */
 5 
 6 #include <stdio.h>
 7 
 8 int maxOfArray(int array[], int length)
 9 {
10     // 数组当做函数参数传递时，会当做指针变量来使用，指针变量在64bit编译器环境下，占据8个字节
11     
12     //int size = sizeof(array);
13     //printf("array=%d\n", size);
14     
15     //sizeof(array);
16     
17     // 1.定义一个变量存储最大值(默认就是首元素)
18     int max = array[0];
19     
20     // 2.遍历所有元素，找出最大值
21     for (int i = 1; i<length; i++)
22     {
23         // 如果当前元素大于max，就用当前元素覆盖max
24         if (array[i] > max)
25         {
26             max = array[i];
27         }
28     }
29     
30     return max;
31 }
32 
33 int main()
34 {
35     int ages[] = {11, 90, 67, 150, 78, 60, 70, 89, 100};
36     
37     int ages2[] = {11, 90, 67, 150, 78, 60, 70, 89, 100};
38     
39     //int size = sizeof(ages);
40     
41     //printf("ages=%d\n", size);
42     int max = maxOfArray(ages, sizeof(ages)/sizeof(int));
43     
44     printf("%d\n", max);
45     return 0;
46 }