一维字符数组的定义及初始化

一维字符数组的定义格式为：

char 数组名[数组大小];

例如：

1. char c[10];

该语句定义了一个一维字符数组 c，大小为 10，即占 10 个字符变量空间，最大可存储长度为 9 的字符串（第 10 个字符为 '0'）。由于没有显式给每个字符变量赋值，故每个字符变量为随机值。

可以采用单个字符逐个赋值的方式初始化，也可以使用字符串初始化的方式。

采用逐个字符赋值的方式

1) 当字符个数少于数组空间大小时，例如：

1. char c[8] = {'h','e','l','l','o',};//始值个数5小于数组空间个数8

该语句定义了含 8 个字符变量的一维字符数组，前 5 个字符变量分别显式初始化为 'h'，'e'，'l'，'l'，'o' 等 5 个字符，后 3 个字符变量为空字符 '\0'。其存储形式如下。

当字符数组中含有字符串结束字符 '\0' 时，可以使用 printf 函数及格式控制符 %s，输出该字符数组中的字符串，如下所示。

1. printf ("%s”，c); //数组名 c 为首字符 'h' 的地址或者为 &c[0]

注意：使用 printf 函数及格式控制符 %s，输出一个字符串时，输出列表中一定为某个字符的地址，且从该字符开始的串一定有结束标志 '\0'。该语句的功能是：从输出列表中的该地址开始，到第一次遇到 '\0' 为止，这之间的字符全部输出。

通常一维数组初始化时，其第一维大小可以省略，例如：

1. char c[]={'h','e','l','l','o'};

对应的数组存储形式如下所示。

由于该数组中不存在 '\0' 字符，故不能使用 printf("%s",c); 输出。

1. char c[8] = {'h','e','l','l','o'};

不等价于

1. char c[]={'h','e','l','l','o'};

2) 当字符个数等于数组空间大小时，例如：

1. char c[5]={'h','e','l','l','o'};//初值个数5等于数组大小5

执行该初始化语句后，数组的存储形式如下所示。

1. char c[5]={'h','e','l','l','o'};

等价于

1. char c[]={'h','e','l','l','o'};

由于该字符数组中不包含字符串结束标志 '\0'，故不能使用 printf("%s"，c); 输出其中的字符串。输出结果中一般含有随机乱码。

这种情况一般采用循环语句逐个输出该数组中的每个字符。

1. int i;
2. for(i=0;i<5;i++) //循环次数为字符个数或数组大小
3. printf ("%c",c[i]);//格式控制符为％c，输出列表中为字符变量c[i]

3) 当字符个数多于空间大小时，编译时报错。例如：

1. char c[4] = {'h','e','l','l','o'}； //错误。初值个数5大于数组大小4

采用字符串初始化的方式

在 C 语言中，字符串一般是指含有字符串结束符 '\0' 的若干个字符的集合。而使用双引号括起来的字符串常量，默认隐含字符串结束符 '\0'。例如：

1. char c[12] = {"C program"}; //注意该数组大小应足够大

用字符串对字符数组初始化时，一般大括号可以去掉，即:

1. char c[12]="C program";

该初始化语句与以下三条语句均是等价的。

1. char c[12]= {'C',' ','p','r','o','g','r','a','m','\0','\0','\0'};

或者:

1. char c[12] = {'C',' ','p','r','o','g','r','a','m','\0'};

或者:

1. char c[12] = {'C',' ','p','r','o','g','r','a','m'};

以上等价初始化语句有一个共同特点：数组的大小均为指定值 12。

其数组存储形式均如下所示。

采用字符串对字符数组进行初始化时，一般省略一维数组空间的大小，即:

1. char c[]="C program";

该数组中除了存储字符串中的 9 个有效字符外，还自动在字符串的结尾存储 '\0' 字符。即该数组的大小为 10。其存储形式如下所示。

为节省空间及书写方便，当用字符串对字符数组初始化时，一般均省略其一维的大小。

一维字符数组的引用

字符数组中的每一个元素都是一个字符，可以使用下标的形式来访问数组中的每一个字符。

例如

1. char c[]="abcd";

定义了一个一维字符数组 c，用字符串常量对其初始化，该数组大小为 5，前 4 个元素的值分别为 'a'、'b'、'c'、'd'，第 5 个元素的值为 '\0'。其存储形式如下所示。

可以使用 c[i] 引用该数组中的每个元素，例如：

1. c[2]='f'; //把'f'赋给元素c[2]
2. scanf("%c",&c[3]); //输入一个字符，保存到元素c[3]对应的地址空间中
3. printf("%c",c[1]); //输出元素c[1]中的字符值

如果每次输出一个字符，可使用循环语句输出字符数组中保存的字符串，参考代码如下。

1. int i;
2. for(i=0;c[i]!='\0';i++) //当前i号位置的字符变量只要不是结束符就输出
3. printf("%c",c[i]);

一维字符教组的应用举例

C 语言中的字符串总是以 '\0' 作为结束标志，所以字符串的长度指的是从字符串的首字符开始，到第一次遇到 '\0' 为止，这之间所包含的有效字符的个数，结束符不计算在字符串长度内。

如字符串”abcd”，C 语言中字符串最后一个有效字符后隐含 '\0' 字符，故该字符串长度为 4。

【例 1】编写实现求一个字符串长度的程序。

分析:把字符串保存在一维字符数组中，其长度用 len 表示，初始为 0。算法为：从该数组的首元素（0 号位置）开始，只要当前元素不为 '\0'，len 加 1，直到遇到 '\0' 为止，此时 len 的值即为该字符串的长度。

实现代码：

1. #include<stdio.h>
2. int main (void)
3. {
4. char str[]="A good book is a good friend!";
5. int i, len=0; //len必须初始化为0
6. for(i=0;str[i]!='\0';i++)
7. len++;
8. printf ("The length is: %d\n",len);
9. return 0;
10. }

运行结果为：
The length is: 29

【补充】该程序循环部分也可以使用 while 循环，如下所示：

1. i=0;
2. while(str[i]!='\0')
3. {
4. len++;
5. i++;
6. }

所谓数组，是指将那些具有相同类型的、数量有限的若干个变量通过有序的方法组织起来的一种便于使用的形式。数组属于一种构造类型，其中的变量被称为数组的元素。数组元素的类型可以是基本数据类型，也可以是特殊类型和构造类型。

一维数组

一位数组是最简单的数组类型，它的定义形式如下：

类型说明符 数组名[常量表达式]

类型说明符是数组中每个元素的类型，常量表达式是数组元素的个数

在使用一维数组的时候需要留意以下两个要点

• 常量表达式的值必须是正整数
• 数组元素的引用，数组的起始元素下标为0

下来我们通过一个简单的示例了解一下数组

代码如下：

#include<stdio.h>
#define N 9
int main(void) {
    int arr[N];
    int i;
    for (i = 0; i < N; i++)
    {
        arr[i] = i + 1;
        printf("arr[%d]=%d\t", i, arr[i]);
        if (0 == (i+1)%3)
        {
            printf("\n");
        }
    }
    return 0;
}

运行结果如下：

我们分析一下上面这段代码

我们定义了一个含有9个元素的一位数组arr，在引用数组中的元素时，采用"数组名[下标]"的方式，将其中的每一个元素视为一个普通的变量来进行操作。需要注意的是，因为定义的数组arr仅含有9个元素，所以在使用的过程中，下标值不能超过8，否则就会出现下标越界的错误，示例如下：

在使用数组的时候要特别注意数组越界，不然很有可能为自己埋下一颗雷(bug)。

接下来我们我们通过一段代码看一下数组在内存中是如何存放的

#include<stdio.h>
#define N 4
int main(void) {
    int arr[N];
    int i;
    for (i = 0; i < N; i++)
    {
        arr[i] = i;
        printf("&arr[%d]=%d\n", i, &arr[i]);
    }
    return 0;
}

运行结果如下：

从结果我们可以看出，每个元素占用4个字节，在内用中的存储结构图如下：

最后我们再通过一个示例来巩固一下一维数组

需求：使用数组保存用户输入的数据，当输入完毕后逆向输出

代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#define N 5
int main(void) {
    int arr[N];//定义数组
    int i, temp;//定义变量
    printf("请输入一个5个元素数组：\n");
    for (i = 0; i < N; i++)
    {
        scanf("%d", &arr[i]);
    }
    printf("读取到的数组如下：\n");
    for (i = 0; i < N; i++)
    {
        printf("%d ",arr[i]);
    }
    printf("\n");
    for (i = 0; i < 2; i++)//将数组中元素的前后位置互换
    {
        temp = arr[i];
        arr[i] = arr[4 - i];
        arr[4 - i] = temp;
    }
    printf("输出的逆向数组如下：\n");
    for (i = 0; i < N; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

运行结果如下：

二维数组

二维数组定义的一般形式如下：

类型说明符 数组名[常量表达式1][常量表达式2]

与一维数组的定义唯一的不同是多了一个常量表达式2，其中，常量表达式1为第一维的长度，常量表达式2为第二维的长度。通常在处理二维数组的时候，为了便于理解，都将数组视为一个矩阵，常量表达式1表示矩阵的行数，而常量表达式2表示矩阵的列数。与一维数组一样，在定义二维数组时，常量表达式同样不能为变量。下面先通过一段代码来看二维数组的定义。

#include<stdio.h>

#define M 4
#define N 3


int main() {
  int arr[M][N];
  for (int i = 0; i < M; i++)
  {
    for (int j = 0; j < N; j++)
    {
      printf("&arr[%d][%d]=%d\t", i, j, &arr[i][j]);
    }
    printf("\n");
  }
  return 0;
}

运行结果：

将二维数组arr视为一个矩阵，下图显示了数组中每个元素在矩阵中的存放位置。

数组中各个元素在矩阵中对应的位置由二维数组的两个下标决定。我们可以将定义的二维数组int arr[4][3]视为由arr[4]和int [3] 两部分构成，将arr[4]视为一个整型一维数组，其中含有4个元素arr[0]、arr[1]、arr[2]、arr[3]，每个元素都是int[3]类型的，也就是说，每个元素又是一个一维数组，每个一维数组含有3个元素，如arr[0]含有arr[0][1]、arr[0][1]、arr[0][2]三个元素。

知道了二维数组的这种特殊结构之后，接下来通过下图来了解二维数组在内存中的存储结构。

通过上述二维数组在内存中的存储结构图可以发现，二维数组中的所有元素都存储在一片连续的内存单元中，所占用的内存大小为元素类型所占用的内存大小乘以第一维及第二维的长度。如果以矩阵的方式来分析二维数组的存储方式，那么先从矩阵第一行从左往右依次存储完所有元素，然后按照同样的方法存储第二行的所有元素，直到存储完所有数组元素为止。

接下来再看一个二维数组的示例：

任意输入一个3行3列的二维数组，求对角元素之和

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

int main() {
  int arr[3][3];
  int i, j, sum = 0;
  printf("please input:\n");
  for (i = 0; i < 3; i++)
  {
    for (j = 0; j < 3; j++)
    {
      scanf("%d", &arr[i][j]);
    }
  }
  for (i = 0; i < 3; i++)
  {
    for ( j = 0; j < 3; j++)
    {
      if (i==j)
      {
        sum += arr[i][j];
      }
    }
  }
  printf("the result is: %d\n", sum);
  return 0;
}

运行结果如下：

字符数组

字符数组顾名思义就是数组的元素类型为字符型的数组。特殊之处在于它是数组元素为字符的数组。其定义的一般形式和注意事项与之前讲解的一般数组类似，只是其中的类型说明符是char。当然，并不是说类型说明符只能是char，也可以是long、int等，但是由于char型只占用一个字节的大小，使用long型和int型来定义字符数组会造成资源的浪费，因此一般选择使用char型来定义字符数组。
一维字符数组
首先通过下面一段代码来看看一维字符数组的定义。

#include<stdio.h>
#define SIZE 20
int main() {
    long arr1[SIZE] = {'h','e','l','l','o',' ','w','o','r','l','d','!'};
    char arr2[SIZE] = { 'h','e','l','l','o',' ','w','o','r','l','d','!' };
    printf("long型字符数组占用的内存大小为：%d\n", sizeof(arr1));
    printf("char型字符数组占用的内存大小为：%d\n", sizeof(arr2));
    return 0;
}

运行结果：

在上面的代码中定义了不同类型的字符数组来存放相同的字符，可以看出，它们占用的内存大小相差很大，long型字符数组所占用内存大小是char型数组占用内存大小的4倍。从这点可以看出，选用char型作为数组类型避免了内存空间的浪费。下面通过一段代码来了解字符数组的初始化特点。

#include<stdio.h>
#define SIZE 20
int main() {
    int i;
    char arr[SIZE] = { 'h','e','l','l','o',' ','w','o','r','l','d','!' };
    for (i = 0; i < SIZE; i++)
    {
        printf("%c", arr[i]);
    }
    
    return 0;
}

运行结果：

运行结果为“Hello World!”，其中有一些空字符。看看上面代码中定义的arr数组，其数组长度为20，而初始化的字符元素的个数为12，初始化的字符元素个数小于数组长度，编译器在编译过程中将后面没有初始化的数组元素赋值为‘\0’，这也正是打印输出中含有空字符的原因。在打印的时候也可以将数组中的元素‘\0’视为数组结束的标志，例如：

#include<stdio.h>
#define SIZE 20
int main() {
    int i;
    long arr[SIZE] = { 'h','e','l','l','o',' ','w','o','r','l','d','!' };
    for (i = 0; arr[i]!='\0'; i++)
    {
        printf("%c", arr[i]);
    }
    
    return 0;
}

运行结果：

这时的输出结果中就不含有任何空字符了，因为巧妙地使用了字符数组中的‘\0’标志。当然，也可以采用字符串常量的方式来对一维字符数组进行初始化，例如：

#include<stdio.h>
#define SIZE 20
int main() {
    int i;
    char arr[SIZE] = { "hello world!" };
    for (i = 0; arr[i] != '\0'; i++)
    {
        printf("%c", arr[i]);
    }
    
    return 0;
}

运行结果：

在对一维字符数组进行定义和初始化的过程中，可以不指定其长度。使用字符常量列表和字符串常量的方式进行初始化的结果是不同的，例如：

#include<stdio.h>
int main() {
    int i;
    char arr1[] = { "hello world!" };
    char arr2[] = {'h','e','l','l','o',' ','w','o','r','l','d','!'};
    
    printf("采用字符串常量进行初始化的arr1数组的长度为：%d\n", sizeof(arr1));
    printf("采用字符常量列表进行初始化的arr2数组的长度为：%d\n", sizeof(arr2));
    
    return 0;
}

运行结果：

从运行结果发现，采用这两种方式得到的数组长度并不相同，在采用字符串常量对字符数组进行初始化的过程中，在内存中进行存储时会自动在字符串的后面添加一个结束符‘\0’，所以得到的字符数组长度是字符串常量的长度加1；而采用字符常量列表的方式对字符数组进行初始化就不会在最后添加一个结束符，所以利用这种方式定义的字符数组的长度就是字符常量列表中字符的个数。

数组实例

交换数组中最大数和最小数的位置

实例代码

//
// Created by 冲哥 on 2021/22/09.
// 实现功能：交换数组中最大数和最小数的位置
//

#include "stdio.h"

int main(){
    int a[10];
    int max, min;
    int m, n;

    printf("请输入10个数字：\n");
    for (int i = 0; i < 10; i++) {
        scanf("%d", &a[i]);
    }
    printf("输入的10个数是：\n");
    for (int i = 0; i < 10; i++) {
        printf("%4d", a[i]);
    }
    printf("\n");
    max = a[0];
    for (int i = 0; i < 10; i++) {
        if (a[i] > max) {
            max = a[i];
            m = i;
        }
    }

    min = a[0];
    for (int i = 0; i < 10; i++) {
        if (a[i] < min) {
            min = a[i];
            n = i;
        }
    }

    a[m] = min;
    a[n] = max;

    printf("交换最大数和最小数的位置后：\n");
    for (int i = 0; i < 10; i++) {
        printf("%4d", a[i]);
    }
} 

运行结果

程序分析

首先找到数组中的最大值和最小值，记录它们的位置，然后交换位置，最后将交换后的数组输出。

如果您觉得本篇文章对您有帮助就顺手点个赞吧
更多干货内容请查看我的个人公众号：C语言中文社区。
【C语言中文社区】是一个C语言/C++视频教程、学习笔记、电子书、计算机二级资料等专注于C语言/C++编程学习者的干货知识分享平台，精选深度文章，分享优秀干货类、技能类的学习资源，帮助学习中的你。