C语言学习笔记-初阶（20）数组1：数组概念、一维数组

1. 数组的概念

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

从这个概念中我们就可以发现2个有价值的信息：

• 数组中存放的是1个或者多个数据（但是数组元素个数不能为0)

• 数组中存放的多个数据，类型是相同的。

数组分为：一维数组、多维数组。

多维数组一般比较多见的是二维数组。

一个变量能管理一个数据；

一个数组能管理一组相同类型的数据；

总结：

• 数组也是C语言中一个非常重要的概念，程序中几乎必用数组；

• 数组的核心作用：方便管理一组同类型的数据。

• 数组和顺序表的区别：数组是用为了管理一组同类型数据而提出的概念，顺序表是一种数据结构。

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

2.1 数组创建

数组的元素：存放在数组里的每一个数据，被称为数组的元素，

数组在创建的时候需要指定数组的大小和数组的元素类型。

——指定的这两个信息一起就构成了数组的类型！！！

一维数组创建的基本语法如下：

type arr_name[常量值];

例：

int arr[5];
char ch[10];

• arr_name：指定数组名的名字。

这个名字根据实际情况，起的有意义就行。

• [ ] 中的常量值：指定数组的大小的，即数组中的元素的个数。

这个数组的大小是根据实际的需求指定就行，而且只能用常量值来指定。

比如：我们现在想存储某个班级的20人的数学成绩，那我们就可以创建⼀个数组，如下：

int math[20];

当然我们也可以根据需要创建其他类型和大小的数组：

char ch[8];
double score[10];

2.2 数组初始化

数组的初始化：有时候，数组在创建的时候，我们需要给定一些初始值，这就称为数组的初始化。

那数组如何初始化呢？

数组的初始化一般使用大括号，将数据放在大括号中（初始化列表）

数组初始化的3种情况：

① 初始化列表的数据个数小于数组大小；

② 初始化列表的数据个数等于数组大小；

③ 初始化列表的数据个数大于数组大小；

2.2.1 完全初始化

//完全初始化
int arr[5] = {1,2,3,4,5};

2.2.2 不完全初始化

//不完全初始化
int arr2[6] = {1};
int arr3[10] = {1, 2, 3, 4, 5};

//不完全初始化
int arr4[10] = {0};//利用不完全初始化的特点，写一个0给每个元素都初始化成0

不完全初始化规则：有值的元素初始化为对应的值，剩余的元素默认初始化为0。

2.2.3 错误的初始化

//错误的初始化 - 初始化项太多
int arr3[3] = {1, 2, 3, 4};

编译报错：C2078 初始值设定项太多。

2.2.4 不指定项数的完全初始化

编译器会根据初始化的内容来设置数组的大小。

所以如果数组初始化了，那就可以省略数组的大小指定——使用起来更方便。

2.2.5 不初始化

随机值

2.3 数组类型

数组也是有类型的，数组算是一种自定义类型。

去掉数组名留下的就是数组的类型。

如下：

int arr1[10];
int arr2[12];
char ch[5];

arr1数组的类型是 int [10]

arr2数组的类型是 int [12]

ch 数组的类型是 char [5]

一个变量的数据类型确定了它的存储方式 & 存储空间大小。

所以：

一个数组的类型，int和[10]都是必要的，结合起来才能确定存储空间的大小——存储方式不用管，都一样。

int [10]才是一个完整的数组类型。

数组的类型不是每个元素的类型，每个元素的类型是int，作为一个数组，它的类型是int [10]。

3. 一维数组的使用

学习了一维数组的基本语法，一维数组可以存放数据，存放数据的目的是对数据的操作。

那我们如何使用一维数组呢？

3.1 数组下标

C语言规定数组是有下标的，下标是从0开始的，依次往后递增1。

假设数组有n个元素，最后一个元素的下标是n-1，下标就相当于数组元素的编号。

例如：

int arr[10] = {1,2,3,4,5,6,7,8,9,10}; 

当我们写下上面这段代码，我们知道我有一个数组，每个元素是int类型，我给它放了1,2,3,4,5,6,7,8,9,10进去，这个时候为了能够把1,2,3,4,5,6,7,8,9,10这些数据存起来，就需要向内存申请一块大的空间，这块连续的空间会划分为10等份，每一个空间都是一个整型空间，也就是在内存中申请了10个整型空间，然后每个整型空间存放了一个值，并且每个空间都有自己的下标（空间的编号，可以理解为门牌号），下标从0开始，依次往后递增1。

接下来如果你想找到这块空间里的值，你可以通过下标来访问数组里的元素。

下标引用操作符：在C语言中数组的访问提供了一个操作符 [ ] ——下标引用操作符。

有了下标访问操作符，我们就可以轻松的访问到数组的元素了，比如我们访问下标为7的元素，我们就 可以使用 arr[7] ，想要访问下标是3的元素，就可以使用 arr[3] ,如下代码：

#include <stdio.h>
int main()
{
 int arr[10] = {1,2,3,4,5,6,7,8,9,10}; 
 printf("%d\n", arr[7]);//8
 printf("%d\n", arr[3]);//4

 return 0;
}

3.2 数组元素的打印

接下来，如果想要访问整个数组的内容，那怎么办呢？

只要我们产生数组所有元素的下标就可以了。

那我们使用for循环产生0~9的下标，接下来使用下标访问就行了。

如下代码：

#include <stdio.h>
int main()
{
 int arr[10] = {1,2,3,4,5,6,7,8,9,10}; 
 int i = 0;
 for(i=0; i<10; i++)
 {
     printf("%d ", arr[i]);
 }

 //while(i<10)
 //{
     //printf("%d ", arr[i]);
     //i++;
 //}
 return 0;
}

for循环的特点：

对于用到循环变量，以一定循环次数作为结束条件的循环，for循环具有结构清晰的优势。

3.3 数组的输入

&：取地址操作符。

明白了数组的访问，当然我们也可以根据需求，自己给数组输入想要的数据，如下：

#include <stdio.h>
int main()
{
 int arr[10] = {0}; 
 int i = 0;
 for(i=0; i<10; i++)
 {
     scanf("%d", &arr[i]);//取每个元素的地址
 }
 for(i=0; i<10; i++)
 {
     printf("%d ", arr[i]);
 }
 return 0;
}

输入、输出结果

4. 一维数组在内存中的存储

有了前面的知识，我们其实使用数组基本没有什么障碍了，如果我们要深入了解数组，我们最好能了解⼀下数组在内存中的存储。

计算机中所有程序要运行起来，都需要向内存申请空间来存储数据、处理数据。

内存4G/16/32G……这么大，怎么管理？——换分为一个个小的内存单元（字节），并编号。

x86环境下，内存地址是32位的二进制号——32根地址线。

32位二进制地址==8位十六进制地址。

x64环境下，内存地址是64位的二进制号——64根地址线。

64位二进制地址==16位十六进制地址。

依次打印数组元素的地址：

%p：地址占位符。

#include <stdio.h>
int main()
{
 int arr[10] = {1,2,3,4,5,6,7,8,9,10}; 
 int i = 0;
 for(i=0; i<10; i++)
 {
     printf("&arr[%d] = %p\n ", i, &arr[i]);//%p 打印地址的占位符
 }
 return 0;
}

输出结果我们看看：

注意：每次程序运行起来地址是不一样的——编译器每次运行都会重新指派地址。

从输出的结果我们发现：

① 数组随着下标的增长，地址是由小到大变化的；

② 每两个相邻的元素之间相差4（一个整型是4个字节）。

所以我们得出结论：数组在内存中是从低地址到高地址连续存放的。

（栈区的局部变量总体是从高地址向地址存放的）

这就为后期我们使用指针访问数组奠定了基础（在讲指针的时候我们在讲，这里暂且记住就行）。——简单来说就是，连续存放的数组，使得我们拿到首元素的地址，顺藤摸瓜就能获得所有元素的地址，进而访问到所有元素。

5. sizeof计算数组元素个数

在遍历数组的时候，我们经常想知道数组的元素个数，才能够确定遍历循环的次数。

那C语言中有办法使用程序计算数组元素个数吗？

答案是有的，可以使用：sizeof。

 sizeof 中C语言是一个关键字，可以计算类型或者变量大小的，单位是字节。

其实 sizeof 也可以计算数组的大小。

比如：

#include <stido.h>

int main()
{
    int arr[10] = {0};
    printf("%d\n", sizeof(arr));
    return 0;
}

这里输出的结果是40，计算的是数组所占内存空间的总大小，单位是字节。

我们又知道数组中所有元素的类型都是相同的，那只要计算出一个元素所占字节的个数，数组的元素个数就能算出来。

这里我们选择第一个元素算大小就可以。

#include <stido.h>

int main()
{
    int arr[10] = {0};
    printf("%d\n", sizeof(arr[0]));//计算⼀个元素的⼤⼩，单位是字节
    return 0;
}

接下来就能计算出数组的元素个数：

#include <stido.h>

int main()
{
    int arr[10] = {0};
    int sz = sizeof(arr)/sizeof(arr[0]);
    printf("%d\n", sz);
    return 0;
}