目录

定义一维数组

一维数组初始化

 引用一维数组元素

数组遍历

计算数组元素和数组字节数 

字符数组

char* 方式引用字符串

---

C 语言中，为了方便操作和管理数据，通常会将同一种类型的多个数据按照一定的形式和顺序组织成有序集合，这些有序数据集合被称为数组。每个数组都有一个名称，被称为数组名。数组中每个数据都有一个确定的编号，被称为数组下标，通过数组名和下标就可以找到数组中指定的数据。

数组从维度上可以划分为一维数组和多维数组。在实际开发中，使用最多的是一维数组

一维数组是 C 语言中最简单、最常用的一类数组，是一种线性数据结构。在系统中，编译器会为数组分配一段连续的内存空间用来存放数据。

定义一维数组

在 C 语言中，一维数组定义的一般形式为：

数据类型 数组名[常量表达式]；

「数据类型」表示数组中每个元素的数据类型；「数组名」用来标识该数组；「常量表达式」用来指定数组中元素的个数，也被称为数组长度。

例如：

int a[10];

上述程序表示，定义长度为 10 的一维数组 a，该数组中每个元素的类型都是 int。

说明：（1）数组名也是标识符，必须符合 C 语言标识符命名规范。

（2）数组长度可以是常量或常量表达式，如 int a[10]和 int a[5+5]都是合法的。

（3）数组长度不能是变量或变量表达式。如 int a[n]和 int a[n+10]都是错误写法。

一维数组初始化

一维数组初始化的方式一般为：

数据类型 数组名[常量表达式] = { 初始化列表 }；

这种方式在定义数组时，使用初始化列表对数组进行初始化。

例如：

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

上述语句表示，定义 int 类型的数组 a，长度为 10，并使用「{ }」中的数据对数组初始化，「{ }」中各个数据之间使用英文逗号进行分割。

 一维数组其他初始化方式

1．一维数组静态初始化

前面讲过一种数组初始化方式是在定义数组时，使用初始化列表进行初始化。这种方式被称为静态初始化，也即定义数组的同时完成初始化。

2．一维数组动态初始化

除了静态初始化，C 语言还提供了另外一种初始化数组的方式，例如：

int a[3]；　　　　　　　 //定义数组，但未初始化

a[0] =1；　　　　　　　　//初始化 a[0]

a[1] =2；　　　　　　　　//初始化 a[1]

a[2] =3；　　　　　　　　//初始化 a[2]

这种方式被称为动态初始化，先定义数组，然后分别对每个元素进行初始化。

 引用一维数组元素

数组元素是数组的基本组成单元，对数组初始化本质上是对数组中各个元素进行初始化，数组中元素的个数在定义数组时确定。例如：int a[10]，表示数组 a 由 10 个 int 类型的数组元素组成。分别为：a[0]、a[1]、a[2]、a[3]、a[4]、a[5]、a[6]、a[7]、a[8]、a[9]。

说明：（1）需要注意的是，数组元素编号从 0 开始，0~9 表示 10 个元素，不存在 a[10]元素。

（2）这 10 个数组元素可以等价为 10 个 int 类型变量。

在 C 语言中引用数组的一般形式为：

数组名[下标]

数组「下标」是数组元素的索引，通过「下标」可以随机访问数组中的元素，「下标」一般为整数类型的常量、变量或表达式。

以 int a[5]为例：

a[0]　　　　　　//数组 a 的第一个元素

a[1]　　　　　　//数组 a 的第二个元素

a[2]　　　　　　//数组 a 的第三个元素

a[3]　　　　　　//数组 a 的第四个元素

a[4]　　　　　　//数组 a 的的五个元素

a[0]是数组 a 的第一个元素，也被称为数组 a 的首元素。

数组遍历

数组本质上是连续的内存空间，是一种线性的数据结构，从另一方面也可以看作是「盛放」数据的容器。由于数组元素在内存中是顺序存放的，因此，可以通过循环结构，依次遍历出数组中的所有元素。本文主要介绍使用 for 循环遍历数组元素，掌握了这种遍历方式，再去理解 while 与 do…while 遍历方式就容易很多。

在 C 语言中，数组元素下标从 0 开始，依次递增 1，到数组长度减 1 停止。例如，int a[5]，数组 a 有 5 个元素，元素下标依次为 0、1、2、3、4。由于数组下标是有规律的递增，因此，可以使用 for 循环对数组元素进行遍历。

下面通过例子来了解数组遍历。

例:循环遍历数组。

01 #include<stdio.h>

02 int main(void)

03 {

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

05　　int i;

06　　for(i=0;i<5;i++)

07　　{

08　　　　printf("%d ",a[i]);

09　　}

10　　getchar();

11　　return 0;

12 }

运行结果：

计算数组元素和数组字节数 

在 C 语言中，每一个数组元素都可以当作一个单独的变量来看待，数组元素的类型就是数组名前面的类型。在程序中，使用 sizeof 运算符可以计算出该数组元素在内存中所占字节数的大小，一般形式为：

sizeof(数组名[下标]);

下面通过例子来了解一下 sizeof 运算符在数组程序中的使用。

例：sizeof 求数组元素字节数。

01 #include<stdio.h>

02 int main()

03 {

04　　int a[3];

05　　int size0=sizeof（a[0]）；　　//计算第 0 个元素字节数

06　　int size1=sizeof（a[1]）；　　//计算第 1 个元素字节数

07　　int size2=sizeof（a[2]）；　　//计算第 2 个元素字节数

08　　printf("%d ",size0);

09　　printf("%d ",size1);

10　　printf("%d ",size2);

11　　getchar();

12　　return 0;

13 }

运行结果如图 所示。

数组总字节数就是数组所有元素所占字节数的总和。例如，int a[3]，在上面演示中，数组 a 每个元素所占字节数都为 4 字节，数组长度为 3，因此数组 a 总字节数为 4×3=12 字节。

在 C 语言中，数组总字节数计算公式可以总结为以下形式：

数组总字节数 = 单个数组元素所占字节数 × 数组长度。

除了利用上式计算之外，C 语言还提供了更加便利的计算方式，直接在 sizeof 括号中写入数组名即可，一般形式为：

sizeof(数组名);

使用上述方式，编译器会自动计算出数组的总字节数，具体应用如下例所示。

sizeof 求数组总字节数。

1 #include<stdio.h>

2 int main()

3 {

4　 int a[3];

5　 int size=sizeof（a）；　　　　 //计算数组总字节数

6　 printf("%d",size);

7　 getchar();

8　 return 0;

9 }

 注：数组定义时可以不初始化，但是必须指定数组长度。

数组定义时，[ ]中只能是常量或常量表达式，不能是变量。

在 VS2012 中，定义数组时，如果「{ }」中没有初始化数据，编译会报错。

数组越界访问。数组越界访问指的是，访问数组元素超过了数组的有效作用范围，将会得到预期之外的数据。（就是说一个四个元素，然后你要引用第七个元素，数组没有就要随机给你一个数）

字符数组

在 C 语言中，字符串的应用的非常广泛，但是却没有字符串类型。为了解决这个问题，C 语言使用字符数组来存储字符串，下面对字符数组进行介绍。

如何定义字符数组
数组元素类型为字符类型的数组就是字符数组，字符数组定义的一般形式为：

char 数组名[常量或常量表达式]；

例如：

char chs[6];

上述程序表示定义 char 类型数组 chs，长度为 6。

字符数组初始化方式有很多种，最常用的是以下两种。

第一种，定义数组时，指定数组长度，并初始化。

例如：

char chs[6]={'r','u','p','e','n','g'};

上述语句定义了字符数组 chs，长度为 6，并使用 6 个字符初始化数组 chs。

第二种，定义数组时，不指定数组长度。

例如：

char chs[ ]={'r','u','p','e','n','g'};

上述语句定义字符数组 chs 时，未指定数组长度，编译器会根据「{ }」中字符个数自动计算出数组 chs 的长度。

C 语言中没有专门的字符串类型，通常使用字符数组来存储字符串。为了区分普通字符数组和字符串，C 语言规定以字符『\0』作为字符串的结束标志，例如：

char c[ ]={'r','u','p','e','n','g'};

以上字符数组中没有『\0』，表示是普通的字符数组。

char c[ ]= {'r','u','p','e','n','g','\0'};

以上字符数组以字符『\0』结束，表示是字符串。

除了以上初始化方式，也可以采用字符串对字符数组进行初始化，例如：

char c[ ]="rupeng";

使用字符串方式进行赋值时，系统会自动在字符串末尾添加『\0』，「rupeng」在内存中实际内存情况如图

 

通过对比可以发现，使用字符串初始化更加简洁，且无需指定字符数组长度，系统会自动计算字符串长度并且添加『\0』。在 C 语言中，采用『\0』作为字符串的结束标志，当系统读取到『\0』时，认为字符串结束，『\0』之后的内容将不再读取。因此，通常将『\0』添加在字符串末尾，保证字符串完整输出。

计算字符串长度

由于字符串底层采用字符数组进行存储，因此计算字符串长度，等价于计算字符串转化为字符数组后字符数组的长度，例如：

char c[ ]="rupeng";

上述代码，经过编译后，会转化为以下字符数组形式：

char c[ ]={'r','u','p','e','n','g','\0'};

前面讲过数组长度计算公式为：数组长度 = 数组总字节数/单个数组元素字节数。该公式对于计算字符串长度同样适用，例如：

int length=sizoef(c)/sizeof(c[0]);

在 C 语言中，字符串有效长度指的是字符串中『\0』之前的字符个数，不包括『\0』。例如：

char c1[ ]={'r','u','p','e','n','g','\0'};

c1 字符串有效长度为 6，不包括最后的『\0』。

char c2[ ]="rupeng";

c2 字符串有效长度为 6，不包括系统自动添加的『\0』。

在实际开发中，为了快速计算字符串有效长度，可以使用 C 语言标准库提供的 strlen 函数。

【函数原型】

int strlen(char str[ ]);

【头文件】

#include<string.h>

【形参列表】

str：被计算的字符串。

【函数功能】

计算字符串的有效长度。

【返回值】

返回字符串的有效长度。

在程序中要使用该函数时，需要引入「string.h」头文件，其一般形式为：

int len=strlen(字符串)

作用是计算字符串的有效长度，并以返回值的形式赋值给变量 len。

char* 方式引用字符串

在 C 语言中，字符串存储的方式只有一种，即采用字符数组格式进行存储。但是引用的方式却有两种，除了前面介绍的字符数组方式，还可以定义 char*类型的变量进行引用。例如：

char* string="rupeng";

以上代码表示，定义 char*类型变量 string，并使用字符串进行初始化。

对于上述代码，有以下几点需要注意。

（1）字符串「rupeng」在内存中，仍采用字符数组形式进行存储。

（2）变量 string 的类型是 char*类型，char 和*是一个整体。

（3）char*与字符数组是两种不同的数据类型，切勿混淆。

（4）字符串并没有存储在 char*类型变量中，仍以字符数组格式存储在内存中，只是将数组在内存中的位置赋值给 char*变量。当程序运行时，通过变量中保存的位置信息就可以找到字符数组。

例： char*方式引用字符串。

1 #include<stdio.h>

2 int main()

3 {

4　 char* string="rupeng";

5　 printf("%s",string);

6　 getchar();

7　 return 0;

8 }

运行结果如图  所示。

char*数组就是数组元素类型为 char*的数组，数组中每个元素都指向字符串。