什么是数组?
1. C语言数组的基本概念
我们举了过这样一个例子,是输出一个 4×4 的整数矩阵,代码如下:
#include <stdio.h>
#include <stdlib.h>
int main()
{
int a1=20, a2=345, a3=700, a4=22;
int b1=56720, b2=9999, b3=20098, b4=2;
int c1=233, c2=205, c3=1, c4=6666;
int d1=34, d2=0, d3=23, d4=23006783;
printf("%-9d %-9d %-9d %-9d\n", a1, a2, a3, a4);
printf("%-9d %-9d %-9d %-9d\n", b1, b2, b3, b4);
printf("%-9d %-9d %-9d %-9d\n", c1, c2, c3, c4);
printf("%-9d %-9d %-9d %-9d\n", d1, d2, d3, d4);
system("pause");
return 0;
}
运行结果:
20 345 700 22
56720 9999 20098 2
233 205 1 6666
34 0 23 23006783
- 矩阵共有 16 个整数,我们为每个整数定义了一个变量,也就是 16 个变量。那么,为了减少变量的数量,让开发更有效率,能不能为多个数据定义一个变量呢?比如,把每一行的整数放在一个变量里面,或者把 16 个整数全部都放在一个变量里面。答案当然是肯定的,办法就是使用数组(Array)。
数组的概念和定义
- 我们知道,要想把数据放入内存,必须先要分配内存空间。放入4个整数,就得分配4个int类型的内存空间:
int a[4];
-
这样,就在内存中分配了4个int类型的内存空间,共 4×4=16 个字节,并为它们起了一个名字,叫a。
-
我们把这样的一组数据的集合称为
数组(Array)
,它所包含的每一个数据叫做数组元素(Element)
,所包含的数据的个数称为数组长度(Length)
,例如int a[4]
;就定义了一个长度为4的整型数组,名字是a。 -
数组中的每个元素都有一个序号,这个序号从0开始,而不是从我们熟悉的1开始,称为
下标(Index)
。使用数组元素时,指明下标即可,形式为:
arrayName[index]
arrayName
为数组名称,index
为下标。例如,a[0] 表示第0个元素,a[3] 表示第3个元素。
- 接下来我们就把第一行的4个整数放入数组:
a[0]=20;
a[1]=345;
a[2]=700;
a[3]=22;
-
这里的0、1、2、3就是数组下标,a[0]、a[1]、a[2]、a[3] 就是数组元素。
-
在学习过程中,我们经常会使用循环结构将数据放入数组中(也就是为数组元素逐个赋值),然后再使用循环结构输出(也就是依次读取数组元素的值),下面我们就来演示一下如何将 1~10 这十个数字放入数组中:
#include <stdio.h>
int main(){
int nums[10];
int i;
//将1~10放入数组中
for(i=0; i<10; i++){
nums[i] = (i+1);
}
//依次输出数组元素
for(i=0; i<10; i++){
printf("%d ", nums[i]);
}
return 0;
}
运行结果:
1 2 3 4 5 6 7 8 9 10
-
变量 i 既是数组下标,也是循环条件;将数组下标作为循环条件,达到最后一个元素时就结束循环。数组 nums 的最大下标是 9,也就是不能超过 10,所以我们规定循环的条件是 i<10,一旦 i 达到 10 就得结束循环。
-
更改上面的代码,让用户输入 10 个数字并放入数组中:
#include <stdio.h>
int main(){
int nums[10];
int i;
//从控制台读取用户输入
for(i=0; i<10; i++){
scanf("%d", &nums[i]); //注意取地址符 &,不要遗忘哦
}
//依次输出数组元素
for(i=0; i<10; i++){
printf("%d ", nums[i]);
}
return 0;
}
运行结果:
22 18 928 5 4 82 30 10 666 888↙
22 18 928 5 4 82 30 10 666 888
-
第 8 行代码中,scanf() 读取数据时需要一个地址(地址用来指明数据的存储位置),而 nums[i] 表示一个具体的数组元素,所以我们要在前边加 & 来获取地址。
-
最后我们来总结一下数组的定义方式:
dataType arrayName[length];
dataType
为数据类型,arrayName
为数组名称,length
为数组长度。例如:
float m[12]; //定义一个长度为 12 的浮点型数组
char ch[9]; //定义一个长度为 9 的字符型数组
- 需要注意的是:
-
数组中每个元素的数据类型必须相同,对于int a[4];,每个元素都必须为 int。
-
数组长度 length 最好是整数或者常量表达式,例如 10、204 等,这样在所有编译器下都能运行通过;如果 length 中包含了变量,例如 n、4m 等,在某些编译器下就会报错,我们将在《C语言变长数组:使用变量指明数组的长度》一节专门讨论这点。
-
访问数组元素时,下标的取值范围为 0 ≤ index < length,过大或过小都会越界,导致数组溢出,发生不可预测的情况,我们将在《C语言数组的越界和溢出》一节重点讨论,请大家务必要引起注意。
数组内存是连续的
-
数组是一个整体,它的内存是连续的;也就是说,数组元素之间是相互挨着的,彼此之间没有一点点缝隙。下图演示了int a[4];在内存中的存储情形:
-
「数组内存是连续的」这一点很重要,所以我使用了一个大标题来强调。连续的内存为指针操作(通过指针来访问数组元素)和内存处理(整块内存的复制、写入等)提供了便利,这使得数组可以作为缓存(临时存储数据的一块内存)使用。大家暂时可能不理解这句话是什么意思,等后边学了指针和内存自然就明白了。
数组的初始化
上面的代码是先定义数组再给数组赋值,我们也可以在定义数组的同时赋值,例如:
int a[4] = {20, 345, 700, 22};
-
数组元素的值由{ }包围,各个值之间以,分隔。
-
对于数组的初始化需要注意以下几点:
-1) 可以只给部分元素赋值。当{ }中值的个数少于元素个数时,只给前面部分元素赋值。例如:
int a[10]={12, 19, 22 , 993, 344};
-
表示只给 a[0]~a[4] 5个元素赋值,而后面 5 个元素自动初始化为 0。
-
当赋值的元素少于数组总体元素的时候,剩余的元素自动初始化为 0:
对于short、int、long,就是整数 0;
对于char,就是字符 '\0';
对于float、double,就是小数 0.0。
- 我们可以通过下面的形式将数组的所有元素初始化为 0:
int nums[10] = {0};
char str[10] = {0};
float scores[10] = {0.0};
- 由于剩余的元素会自动初始化为 0,所以只需要给第 0 个元素赋值为 0 即可。
-2) 只能给元素逐个赋值,不能给数组整体赋值。例如给 10 个元素全部赋值为 1,只能写作:
int a[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
而不能写作:
int a[10] = 1;
-3) 如给全部元素赋值,那么在定义数组时可以不给出数组长度。例如:
int a[] = {1, 2, 3, 4, 5};
等价于
int a[5] = {1, 2, 3, 4, 5};
- 最后,我们借助数组来输出一个 4×4 的矩阵:
#include <stdio.h>
int main()
{
int a[4] = {20, 345, 700, 22};
int b[4] = {56720, 9999, 20098, 2};
int c[4] = {233, 205, 1, 6666};
int d[4] = {34, 0, 23, 23006783};
printf("%-9d %-9d %-9d %-9d\n", a[0], a[1], a[2], a[3]);
printf("%-9d %-9d %-9d %-9d\n", b[0], b[1], b[2], b[3]);
printf("%-9d %-9d %-9d %-9d\n", c[0], c[1], c[2], c[3]);
printf("%-9d %-9d %-9d %-9d\n", d[0], d[1], d[2], d[3]);
return 0;
}
6.2 C语言二维数组
二维数组的定义
- 二维数组定义的一般形式是:
dataType arrayName[length1][length2];
-
其中,dataType 为数据类型,arrayName 为数组名,length1 为第一维下标的长度,length2 为第二维下标的长度。
-
我们可以将二维数组看做一个 Excel 表格,有行有列,length1 表示行数,length2 表示列数,要在二维数组中定位某个元素,必须同时指明行和列。
例如:
int a[3][4];
- 定义了一个 3 行 4 列的二维数组,共有 3×4=12 个元素,数组名为 a,即:
a[0][0], a[0][1], a[0][2], a[0][3]
a[1][0], a[1][1], a[1][2], a[1][3]
a[2][0], a[2][1], a[2][2], a[2][3]
-
如果想表示第 2 行第 1 列的元素,应该写作 a[2][1]。
-
也可以将二维数组看成一个坐标系,有 x 轴和 y 轴,要想在一个平面中确定一个点,必须同时知道 x 轴和 y 轴。
-
二维数组在概念上是二维的,但在内存中是连续存放的;换句话说,二维数组的各个元素是相互挨着的,彼此之间没有缝隙。那么,如何在线性内存中存放二维数组呢?有两种方式:
1.一种是按行排列, 即放完一行之后再放入第二行;
2.另一种是按列排列, 即放完一列之后再放入第二列。 -
在C语言中,二维数组是按行排列的
。也就是先存放 a[0] 行,再存放 a[1] 行,最后存放 a[2] 行;每行中的 4 个元素也是依次存放。数组 a 为 int 类型,每个元素占用 4 个字节,整个数组共占用 4×(3×4)=48 个字节。 -
你可以这样认为,二维数组是由多个长度相同的一维数组构成的。
-
【实例1】一个学习小组有 5 个人,每个人有 3 门课程的考试成绩,求该小组各科的平均分和总平均分。
— — | Math | C | English |
---|---|---|---|
80 | 75 | 92 | |
61 | 65 | 71 | |
59 | 63 | 70 | |
85 | 87 | 90 | |
76 | 77 | 85 |
- 对于该题目,可以定义一个二维数组 a[5][3] 存放 5 个人 3 门课的成绩,定义一个一维数组 v[3] 存放各科平均分,再定义一个变量 average 存放总平均分。最终编程如下:
#include <stdio.h>
int main(){
int i, j; //二维数组下标
int sum = 0; //当前科目的总成绩
int average; //总平均分
int v[3]; //各科平均分
int a[5][3]; //用来保存每个同学各科成绩的二维数组
printf("Input score:\n");
for(i=0; i<3; i++){
for(j=0; j<5; j++){
scanf("%d", &a[j][i]); //输入每个同学的各科成绩
sum += a[j][i]; //计算当前科目的总成绩
}
v[i]=sum/5; // 当前科目的平均分
sum=0;
}
average = (v[0] + v[1] + v[2]) / 3;
printf("Math: %d\nC Languag: %d\nEnglish: %d\n", v[0], v[1], v[2]);
printf("Total: %d\n", average);
return 0;
}
运行结果:
Input score:
80 61 59 85 76 75 65 63 87 77 92 71 70 90 85↙
Math: 72
C Languag: 73
English: 81
Total: 75
- 程序使用了一个嵌套循环来读取所有学生所有科目的成绩。在内层循环中依次读入某一门课程的各个学生的成绩,并把这些成绩累加起来,退出内层循环(进入外层循环)后再把该累加成绩除以 5 送入 v[i] 中,这就是该门课程的平均分。外层循环共循环三次,分别求出三门课各自的平均成绩并存放在数组 v 中。所有循环结束后,把 v[0]、v[1]、v[2] 相加除以 3 就可以得到总平均分。
二维数组的初始化(赋值)
-
二维数组的初始化可以按行分段赋值,也可按行连续赋值。
-
例如,对于数组 a[5][3],按行分段赋值应该写作:
int a[5][3]={ {80,75,92}, {61,65,71}, {59,63,70}, {85,87,90}, {76,77,85} };
- 按行连续赋值应该写作:
int a[5][3]={80, 75, 92, 61, 65, 71, 59, 63, 70, 85, 87, 90, 76, 77, 85};
-
这两种赋初值的结果是完全相同的。
-
【实例2】和“实例1”类似,依然求各科的平均分和总平均分,不过本例要求在初始化数组的时候直接给出成绩。
#include <stdio.h>
int main(){
int i, j; //二维数组下标
int sum = 0; //当前科目的总成绩
int average; //总平均分
int v[3]; //各科平均分
int a[5][3] = {{80,75,92}, {61,65,71}, {59,63,70}, {85,87,90}, {76,77,85}};
for(i=0; i<3; i++){
for(j=0; j<5; j++){
sum += a[j][i]; //计算当前科目的总成绩
}
v[i] = sum / 5; // 当前科目的平均分
sum = 0;
}
average = (v[0] + v[1] + v[2]) / 3;
printf("Math: %d\nC Languag: %d\nEnglish: %d\n", v[0], v[1], v[2]);
printf("Total: %d\n", average);
return 0;
}
运行结果:
Math: 72
C Languag: 73
English: 81
Total: 75
对于二维数组的初始化还要注意以下几点:
`1) 可以只对部分元素赋值,未赋值的元素自动取“零”值。例如:
int a[3][3] = {{1}, {2}, {3}};
-
是对每一行的第一列元素赋值,未赋值的元素的值为 0。赋值后各元素的值为:
1 0 0
2 0 0
3 0 0 -
再如:
int a[3][3] = {{0,1}, {0,0,2}, {3}};
赋值后各元素的值为:
0 1 0
0 0 2
3 0 0
`2) 如果对全部元素赋值,那么第一维的长度可以不给出。例如:
int a[3][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
- 可以写为:
int a[][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
`3) 二维数组可以看作是由一维数组嵌套而成的;如果一个数组的每个元素又是一个数组,那么它就是二维数组。当然,前提是各个元素的类型必须相同。根据这样的分析,一个二维数组也可以分解为多个一维数组,C语言允许这种分解。
- 例如,二维数组a[3][4]可分解为三个一维数组,它们的数组名分别为 a[0]、a[1]、a[2]。
- 这三个一维数组可以直接拿来使用。这三个一维数组都有 4 个元素,比如,一维数组 a[0] 的元素为 a[0][0]、a[0][1]、a[0][2]、a[0][3]。
1.3 C语言判断数组中是否包含某个元素
对无序数组的查询
- 所谓无序数组,就是数组元素的排列没有规律。无序数组元素查询的思路也很简单,就是用循环遍历数组中的每个元素,把要查询的值挨个比较一遍。请看下面的代码:
#include <stdio.h>
int main(){
int nums[10] = {1, 10, 6, 296, 177, 23, 0, 100, 34, 999};
int i, num, thisindex = -1;
printf("Input an integer: ");
scanf("%d", &num);
for(i=0; i<10; i++){
if(nums[i] == num){
thisindex = i;
break;
}
}
if(thisindex < 0){
printf("%d isn't in the array.\n", num);
}else{
printf("%d is in the array, it's index is %d.\n", num, thisindex);
}
return 0;
}
运行结果:
Input an integer: 100↙
100 is in the array, it’s index is 7.
或者
Input an integer: 28↙
28 isn’t in the array.
-
这段代码的作用是让用户输入一个数字,判断该数字是否在数组中,如果在,就打印出下标。
-
第10~15行代码是关键,它会遍历数组中的每个元素,和用户输入的数字进行比较,如果相等就获取它的下标并跳出循环。
-
注意:数组下标的取值范围是非负数,当 thisindex >= 0 时,该数字在数组中,当 thisindex < 0 时,该数字不在数组中,所以在定义 thisindex 变量时,必须将其初始化为一个负数。
对有序数组的查询
-
查询无序数组需要遍历数组中的所有元素,而查询有序数组只需要遍历其中一部分元素。例如有一个长度为 10 的整型数组,它所包含的元素按照从小到大的顺序(升序)排列,假设比较到第 4 个元素时发现它的值大于输入的数字,那么剩下的 5 个元素就没必要再比较了,肯定也大于输入的数字,这样就减少了循环的次数,提高了执行效率。
-
请看下面的代码:
#include <stdio.h>
int main(){
int nums[10] = {0, 1, 6, 10, 23, 34, 100, 177, 296, 999};
int i, num, thisindex = -1;
printf("Input an integer: ");
scanf("%d", &num);
for(i=0; i<10; i++){
if(nums[i] == num){
thisindex = i;
break;
}else if(nums[i] > num){
break;
}
}
if(thisindex < 0){
printf("%d isn't in the array.\n", num);
}else{
printf("%d is in the array, it's index is %d.\n", num, thisindex);
}
return 0;
}
- 与前面的代码相比,这段代码的改动很小,只增加了一个判断语句,也就是 12~14 行。因为数组元素是升序排列的,所以当 nums[i] > num 时,i 后边的元素也都大于 num 了,num 肯定不在数组中了,就没有必要再继续比较了,终止循环即可。
1.4 C语言字符数组和字符串
用来存放字符的数组称为字符数组
,例如:
char a[10]; //一维字符数组
char b[5][10]; //二维字符数组
char c[20]={'c', ' ', 'p', 'r', 'o', 'g', 'r', 'a','m'}; // 给部分数组元素赋值
char d[]={'c', ' ', 'p', 'r', 'o', 'g', 'r', 'a', 'm' }; //对全体元素赋值时可以省去长度
-
字符数组实际上是一系列字符的集合,也就是
字符串(String)
。在C语言中,没有专门的字符串变量,没有string类型,通常就用一个字符数组来存放一个字符串。 -
C语言规定,可以将字符串直接赋值给字符数组,例如:
char str[30] = {"c.biancheng.net"};
char str[30] = "c.biancheng.net"; //这种形式更加简洁,实际开发中常用
数组第 0 个元素为'c'
,第 1 个元素为'.'
,第 2 个元素为'b'
后面的元素以此类推。
- 为了方便,你也可以不指定数组长度,从而写作:
char str[] = {"c.biancheng.net"};
char str[] = "c.biancheng.net"; //这种形式更加简洁,实际开发中常用
-
给字符数组赋值时,我们通常使用这种写法,将字符串一次性地赋值(可以指明数组长度,也可以不指明),而不是一个字符一个字符地赋值,那样做太麻烦了。
-
这里需要留意一个坑,字符数组只有在定义时才能将整个字符串一次性地赋值给它,一旦定义完了,就只能一个字符一个字符地赋值了。请看下面的例子:
char str[7];
str = "abc123"; //错误
//正确
str[0] = 'a'; str[1] = 'b'; str[2] = 'c';
str[3] = '1'; str[4] = '2'; str[5] = '3';
字符串结束标志(划重点)
- 字符串是一系列连续的字符的组合,要想在内存中定位一个字符串,除了要知道它的开头,还要知道它的结尾。
找到字符串的开头很容易,知道它的名字(字符数组名或者字符串名)就可以;
然而,如何找到字符串的结尾呢?C语言的解决方案有点奇妙,或者说有点奇葩。
在C语言中,字符串总是以'\0'作为结尾,所以'\0'也被称为字符串结束标志,或者字符串结束符。
'\0'是 ASCII 码表中的第 0 个字符,英文称为NUL,中文称为“空字符”。该字符既不能显示,也没有控制功能,输出该字符不会有任何效果,它在C语言中唯一的作用就是作为字符串结束标志。
-
C语言在处理字符串时,会从前往后逐个扫描字符,一旦遇到
'\0'
就认为到达了字符串的末尾,就结束处理。'\0'
至关重要,没有'\0'
就意味着永远也到达不了字符串的结尾。 -
" "
包围的字符串会自动在末尾添加'\0'
。例如,"abc123"
从表面看起来只包含了 6 个字符,其实不然,C语言会在最后隐式地添加一个'\0'
,这个过程是在后台默默地进行的,所以我们感受不到。 -
下图演示了"C program"在内存中的存储情形:
-
需要注意的是,逐个字符地给数组赋值并不会自动添加’\0’,例如:
char str[] = {'a', 'b', 'c'};
-数组 str 的长度为 3,而不是 4,因为最后没有'\0'
。
- 当用字符数组存储字符串时,要特别注意
'\0'
,要为'\0'
留个位置;这意味着,字符数组的长度至少要比字符串的长度大 1。请看下面的例子:
char str[7] = "abc123";
- ````“abc123”```看起来只包含了 6 个字符,我们却将 str 的长度定义为 7,就是为了能够容纳最后的’\0’。如果将 str 的长度定义为 6,它就无法容纳’\0’了。
当字符串长度大于数组长度时,有些较老或者不严格的编译器并不会报错,甚至连警告都没有,这就为以后的错误埋下了伏笔,读者自己要多多注意。
- 些时候,程序的逻辑要求我们必须逐个字符地为数组赋值,这个时候就很容易遗忘字符串结束标志
'\0'
。下面的代码中,我们将 26 个大写英文字符存入字符数组,并以字符串的形式输出:
#include <stdio.h>
int main(){
char str[30];
char c;
int i;
for(c=65,i=0; c<=90; c++,i++){
str[i] = c;
}
printf("%s\n", str);
return 0;
}
在 VS2015 下的运行结果:
ABCDEFGHIJKLMNOPQRSTUVWXYZ口口口口i口口0 ?
口表示无法显示的特殊字符。
大写字母在 ASCII 码表中是连续排布的,编码值从 65 开始,到 90 结束,使用循环非常方便。
-
在很多编译器下,局部变量的初始值是随机的,是垃圾值,而不是我们通常认为的“零”值。局部数组(在函数内部定义的数组,本例中的 str 数组就是在 main() 函数内部定义的)也有这个问题,很多编译器并不会把局部数组的内存都初始化为“零”值,而是放任不管,爱是什么就是什么,所以它们的值也是没有意义的,也是垃圾值。
-
在函数内部定义的变量、数组、结构体、共用体等都称为局部数据。在很多编译器下,局部数据的初始值都是随机的、无意义的,而不是我们通常认为的“零”值。这一点非常重要,大家一定要谨记,否则后面会遇到很多奇葩的错误。
-
本例中的 str 数组在定义完成以后并没有立即初始化,所以它所包含的元素的值都是随机的,只有很小的概率会是“零”值。循环结束以后,str 的前 26 个元素被赋值了,剩下的 4 个元素的值依然是随机的,不知道是什么。
-
printf() 输出字符串时,会从第 0 个元素开始往后检索,直到遇见
'\0'
才停止,然后把'\0'
前面的字符全部输出,这就是 printf() 输出字符串的原理。本例中我们使用 printf() 输出 str,按理说到了第 26 个元素就能检索到'\0'
,就到达了字符串的末尾,然而事实却不是这样,由于我们并未对最后 4 个元素赋值,所以第 26 个元素不是'\0'
,第 27 个也不是,第 28 个也不是……可能到了第 50 个元素才遇到'\0'
,printf() 把这 50 个字符全部输出出来,就是上面的样子,多出来的字符毫无意义,甚至不能显示。 -
数组总共才 30 个元素,到了第 50 个元素不早就超出数组范围了吗?是的,的确超出范围了!然而,数组后面依然有其它的数据,printf() 也会将这些数据作为字符串输出。
-
你看,不注意
'\0'
的后果有多严重,不但不能正确处理字符串,甚至还会毁坏其它数据。 -
要想避免这些问题也很容易,在字符串的最后手动添加’\0’即可。修改上面的代码,在循环结束后添加’\0’:
#include <stdio.h>
int main(){
char str[30];
char c;
int i;
for(c=65,i=0; c<=90; c++,i++){
str[i] = c;
}
str[i] = 0; //此处为添加的代码,也可以写作 str[i] = '\0';
printf("%s\n", str);
return 0;
}
-
第 9 行为新添加的代码,它让字符串能够正常结束。根据 ASCII 码表,字符
'\0'
的编码值就是 0。 -
但是,这样的写法貌似有点业余,或者说不够简洁,更加专业的做法是将数组的所有元素都初始化为“零”值,这样才能够从根本上避免问题。再次修改上面的代码:
#include <stdio.h>
int main(){
char str[30] = {0}; //将所有元素都初始化为 0,或者说 ‘\0’
char c;
int i;
for(c=65,i=0; c<=90; c++,i++){
str[i] = c;
}
printf(“%s\n”, str);return 0;
} -
如果只初始化部分数组元素,那么剩余的数组元素也会自动初始化为“零”值,所以我们只需要将 str 的第 0 个元素赋值为 0,剩下的元素就都是 0 了。
字符串长度
- 所谓字符串长度,就是字符串包含了多少个字符(不包括最后的结束符
'\0'
)。例如"abc"
的长度是 3,而不是 4。 - 在C语言中,我们使用string.h头文件中的 strlen() 函数来求字符串的长度,它的用法为:
length strlen(strname);
strname
是字符串的名字,或者字符数组的名字;length
是使用strlen()
后得到的字符串长度,是一个整数。- 下面是一个完整的例子:
#include <stdio.h>
#include <string.h> //记得引入该头文件
int main(){
char str[] = "http://M.y.cyuyan.net/c/";
long len = strlen(str);
printf("The lenth of the string is %ld.\n", len);
return 0;
}
运行结果:
The lenth of the string is 25.
1.5 C语言字符串的输入和输出
字符串的输出
- 在C语言中,有两个函数可以在控制台(显示器)上输出字符串,它们分别是:
puts():输出字符串并自动换行,该函数只能输出字符串。
printf():通过格式控制符%s输出字符串,不能自动换行。除了字符串,printf() 还能输出其他类型的数据。
- 这两个函数相信大家已经非常熟悉了,这里不妨再演示一下,请看下面的代码:
#include <stdio.h>
int main(){
char str[] = "http://c.biancheng.net";
printf("%s\n", str); //通过字符串名字输出
printf("%s\n", "http://c.biancheng.net"); //直接输出
puts(str); //通过字符串名字输出
puts("http://c.biancheng.net"); //直接输出
return 0;
}
运行结果:
http://c.biancheng.net
http://c.biancheng.net
http://c.biancheng.net
http://c.biancheng.net
- 注意,输出字符串时只需要给出名字,不能带后边的
[ ]
,例如,下面的两种写法都是错误的:
printf("%s\n", str[]);
puts(str[10]);
字符串的输入
- 在C语言中,有两个函数可以让用户从键盘上输入字符串,它们分别是:
scanf():通过格式控制符%s输入字符串。除了字符串,scanf() 还能输入其他类型的数据。
gets():直接输入字符串,并且只能输入字符串。
-
但是,scanf() 和 gets() 是有区别的:
1.scanf() 读取字符串时以空格为分隔,遇到空格就认为当前字符串结束了,所以无法读取含有空格的字符串。
2.gets() 认为空格也是字符串的一部分,只有遇到回车键时才认为字符串输入结束,所以,不管输入了多少个空格,只要不按下回车键,对 gets() 来说就是一个完整的字符串。换句话说,gets() 用来读取一整行字符串。 -
请看下面的例子:
#include <stdio.h>
int main(){
char str1[30] = {0};
char str2[30] = {0};
char str3[30] = {0};
//gets() 用法
printf("Input a string: ");
gets(str1);
//scanf() 用法
printf("Input a string: ");
scanf("%s", str2);
scanf("%s", str3);
printf("\nstr1: %s\n", str1);
printf("str2: %s\n", str2);
printf("str3: %s\n", str3);
return 0;
}
运行结果:
Input a string: C C++ Java Python↙
Input a string: PHP JavaScript↙
str1: C C++ Java Python
str2: PHP
str3: JavaScript
-
第一次输入的字符串被 gets() 全部读取,并存入 str1 中。第二次输入的字符串,前半部分被第一个 scanf() 读取并存入 str2 中,后半部分被第二个 scanf() 读取并存入 str3 中。
-
注意,scanf() 在读取数据时需要的是数据的地址,这一点是恒定不变的,所以对于 int、char、float 等类型的变量都要在前边添加
&
以获取它们的地址。但是在本段代码中,我们只给出了字符串的名字,却没有在前边添加&
,这是为什么呢?因为字符串名字或者数组名字在使用的过程中一般都会转换为地址,所以再添加&
就是多此一举,甚至会导致错误了。
就目前学到的知识而言,int、char、float 等类型的变量用于 scanf() 时都要在前面添加&,而数组或者字符串用于 scanf() 时不用添加&,它们本身就会转换为地址。读者一定要谨记这一点。
其实 scanf() 也可以读取带空格的字符串
- 以上是 scanf() 和 gets() 的一般用法,很多教材也是这样讲解的,所以大部分初学者都认为 scanf() 不能读取包含空格的字符串,不能替代 gets()。其实不然,scanf() 的用法还可以更加复杂和灵活,它不但可以完全替代 gets() 读取一整行字符串,而且比 gets() 的功能更加强大。比如,以下功能都是 gets() 不具备的:
scanf() 可以控制读取字符的数目;
scanf() 可以只读取指定的字符;
scanf() 可以不读取某些字符;
scanf() 可以把读取到的字符丢弃。
1.6 C语言字符串处理函数
-
C语言提供了丰富的字符串处理函数,可以对字符串进行输入、输出、合并、修改、比较、转换、复制、搜索等操作,使用这些现成的函数可以大大减轻我们的编程负担。
-
用于输入输出的字符串函数,例如
printf、puts、scanf、gets
等,使用时要包含头文件stdio.h
,而使用其它字符串函数要包含头文件string.h
。 -
string.h
是一个专门用来处理字符串的头文件,它包含了很多字符串处理函数,由于篇幅限制,本节只能讲解几个常用的,有兴趣的读者请猛击这里查阅所有函数。
字符串连接函数 strcat()
- strcat 是 string catenate 的缩写,意思是把两个字符串拼接在一起,语法格式为:
strcat(arrayName1, arrayName2);
-
arrayName1、arrayName2 为需要拼接的字符串。
-
strcat() 将把 arrayName2 连接到 arrayName1 后面,并删除原来 arrayName1 最后的结束标志
'\0'
。这意味着,arrayName1 必须足够长,要能够同时容纳 arrayName1 和 arrayName2,否则会越界(超出范围)。
-
strcat() 的返回值为 arrayName1 的地址。
-
下面是一个简单的演示:
#include <stdio.h>
#include <string.h>
int main(){
char str1[100]="The URL is ";
char str2[60];
printf("Input a URL: ");
gets(str2);
strcat(str1, str2);
puts(str1);
return 0;
}
运行结果:
Input a URL: http://c.biancheng.net/cpp/u/jiaocheng/↙
The URL is http://c.biancheng.net/cpp/u/jiaocheng/
字符串复制函数 strcpy()
strcpy
是string copy
的缩写,意思是字符串复制,也即将字符串从一个地方复制到另外一个地方,语法格式为:
strcpy(arrayName1, arrayName2);
- strcpy() 会把 arrayName2 中的字符串拷贝到 arrayName1 中,字符串结束标志’\0’也一同拷贝。请看下面的例子:
#include <stdio.h>
#include <string.h>
int main(){
char str1[50] = "《C语言变怪兽》";
char str2[50] = "http://c.biancheng.net/cpp/u/jiaocheng/";
strcpy(str1, str2);
printf("str1: %s\n", str1);
return 0;
}
运行结果:
str1: http://c.biancheng.net/cpp/u/jiaocheng/
-
你看,将 str2 复制到 str1 后,str1 中原来的内容就被覆盖了。
-
另外,strcpy() 要求 arrayName1 要有足够的长度,否则不能全部装入所拷贝的字符串。
字符串比较函数 strcmp() -
strcmp 是 string compare 的缩写,意思是字符串比较,语法格式为:
strcmp(arrayName1, arrayName2);
-
arrayName1 和 arrayName2 是需要比较的两个字符串。
-
字符本身没有大小之分,strcmp() 以各个字符对应的 ASCII 码值进行比较。strcmp() 从两个字符串的第 0 个字符开始比较,如果它们相等,就继续比较下一个字符,直到遇见不同的字符,或者到字符串的末尾。
-
返回值:若 arrayName1 和 arrayName2 相同,则返回0;若 arrayName1 大于 arrayName2,则返回大于 0 的值;若 arrayName1 小于 arrayName2,则返回小于0 的值。
-
对4组字符串进行比较:
#include <stdio.h>
#include <string.h>
int main(){
char a[] = "aBcDeF";
char b[] = "AbCdEf";
char c[] = "aacdef";
char d[] = "aBcDeF";
printf("a VS b: %d\n", strcmp(a, b));
printf("a VS c: %d\n", strcmp(a, c));
printf("a VS d: %d\n", strcmp(a, d));
return 0;
}
运行结果:
a VS b: 32
a VS c: -31
a VS d: 0
1.7 C语言对数组元素进行排序(冒泡排序法)
-
在实际开发中,有很多场景需要我们将数组元素按照从大到小(或者从小到大)的顺序排列,这样在查阅数据时会更加直观,例如:
一个保存了班级学号的数组,排序后更容易分区好学生和坏学生;
一个保存了商品单价的数组,排序后更容易看出它们的性价比。 -
对数组元素进行排序的方法有很多种,比如冒泡排序、归并排序、选择排序、插入排序、快速排序等,其中最经典最需要掌握的是
「冒泡排序」
。 -
以从小到大排序为例,冒泡排序的整体思想是这样的:
1.从数组头部开始,不断比较相邻的两个元素的大小,让较大的元素逐渐往后移动(交换两个元素的值),直到数组的末尾。经过第一轮的比较,就可以找到最大的元素,并将它移动到最后一个位置。
2.第一轮结束后,继续第二轮。仍然从数组头部开始比较,让较大的元素逐渐往后移动,直到数组的倒数第二个元素为止。经过第二轮的比较,就可以找到次大的元素,并将它放到倒数第二个位置。
3.以此类推,进行 n-1(n 为数组长度)轮“冒泡”后,就可以将所有的元素都排列好。 -
整个排序过程就好像气泡不断从水里冒出来,最大的先出来,次大的第二出来,最小的最后出来,所以将这种排序方式称为冒泡排序(Bubble Sort)。
-
下面我们以“3 2 4 1”为例对冒泡排序进行说明。
-
第一轮 排序过程
3 2 4 1 (最初)
2 3 4 1 (比较3和2,交换)
2 3 4 1 (比较3和4,不交换)
2 3 1 4 (比较4和1,交换)
第一轮结束,最大的数字 4 已经在最后面,因此第二轮排序只需要对前面三个数进行比较。 -
第二轮 排序过程
2 3 1 4 (第一轮排序结果)
2 3 1 4 (比较2和3,不交换)
2 1 3 4 (比较3和1,交换)
第二轮结束,次大的数字 3 已经排在倒数第二个位置,所以第三轮只需要比较前两个元素。 -
第三轮 排序过程
2 1 3 4 (第二轮排序结果)
1 2 3 4 (比较2和1,交换) -
至此,排序结束。
算法总结及实现
- 对拥有 n 个元素的数组 R[n] 进行 n-1 轮比较。
1.第一轮,逐个比较 (R[1], R[2]), (R[2], R[3]), (R[3], R[4]), ……. (R[N-1], R[N]),最大的元素被移动到 R[n] 上。
2.第二轮,逐个比较 (R[1], R[2]), (R[2], R[3]), (R[3], R[4]), ……. (R[N-2], R[N-1]),次大的元素被移动到 R[n-1] 上。
。。。。。。
3.以此类推,直到整个数组从小到大排序。
- 具体的代码实现如下所示:
#include <stdio.h>
int main(){
int nums[10] = {4, 5, 2, 10, 7, 1, 8, 3, 6, 9};
int i, j, temp;
//冒泡排序算法:进行 n-1 轮比较
for(i=0; i<10-1; i++){
//每一轮比较前 n-1-i 个,也就是说,已经排序好的最后 i 个不用比较
for(j=0; j<10-1-i; j++){
if(nums[j] > nums[j+1]){
temp = nums[j];
nums[j] = nums[j+1];
nums[j+1] = temp;
}
}
}
//输出排序后的数组
for(i=0; i<10; i++){
printf("%d ", nums[i]);
}
printf("\n");
return 0;
}
运行结果:
1 2 3 4 5 6 7 8 9 10
优化算法
-
上面的算法是大部分教材中提供的算法,其中有一点是可以优化的:当比较到第 i 轮的时候,如果剩下的元素已经排序好了,那么就不用再继续比较了,跳出循环即可,这样就减少了比较的次数,提高了执行效率。
-
未经优化的算法一定会进行 n-1 轮比较,经过优化的算法最多进行 n-1 轮比较,高下立判。
-
优化后的算法实现如下所示:
#include <stdio.h>
int main(){
int nums[10] = {4, 5, 2, 10, 7, 1, 8, 3, 6, 9};
int i, j, temp, isSorted;
//优化算法:最多进行 n-1 轮比较
for(i=0; i<10-1; i++){
isSorted = 1; //假设剩下的元素已经排序好了
for(j=0; j<10-1-i; j++){
if(nums[j] > nums[j+1]){
temp = nums[j];
nums[j] = nums[j+1];
nums[j+1] = temp;
isSorted = 0; //一旦需要交换数组元素,就说明剩下的元素没有排序好
}
}
if(isSorted) break; //如果没有发生交换,说明剩下的元素已经排序好了
}
for(i=0; i<10; i++){
printf("%d ", nums[i]);
}
printf("\n");
return 0;
}
-
我们额外设置了一个变量
isSorted
,用它作为标志,值为“真”表示剩下的元素已经排序好了,值为“假”表示剩下的元素还未排序好。 -
每一轮比较之前,我们预先假设剩下的元素已经排序好了,并将
isSorted
设置为“真”,一旦在比较过程中需要交换元素,就说明假设是错的,剩下的元素没有排序好,于是将isSorted
的值更改为“假”。 -
每一轮循环结束后,通过检测
isSorted
的值就知道剩下的元素是否排序好。
1.8 对C语言数组的总结
对数组的总结
`1) 数组的定义格式为:
type arrayName[length]
type
为数据类型,arrayName
为数组名,length
为数组长度。 需要注意的是:- 数组长度 length 最好是常量表达式,例如 10、204 等,这样在所有编译器下都能运行通过;如果 length 中包含了变量,例如 n、4m 等,在某些编译器下就会报错。
- 数组是一个整体,它的内存是连续的;也就是说,数组元素之间是相互挨着的,彼此之间没有一点点缝隙。
- 一般情况下,数组名会转换为数组的地址,需要使用地址的地方,直接使用数组名即可。
`2) 访问数组元素的格式为:
arrayName[index]
index
为数组下标。注意index
的值必须大于等于零,并且小于数组长度,否则会发生数组越界,出现意想不到的错误。
`3) 可以对数组中的单个元素赋值,也可以整体赋值,例如:
// 对单个元素赋值
int a[3];
a[0] = 3;
a[1] = 100;
a[2] = 34;
// 整体赋值(不指明数组长度)
float b[] = { 23.3, 100.00, 10, 0.34 };
// 整体赋值(指明数组长度)
int m[10] = { 100, 30, 234 };
// 字符数组赋值
char str1[] = "http://c.biancheng.net";
// 将数组所有元素都初始化为0
int arr[10] = {0};
char str2[20] = {0};
`4) 字符串是本章的重点内容,大家要特别注意字符串结束标志’\0’,各种字符串处理函数在定位字符串时都把’\0’作为结尾,没有’\0’就到达不了字符串的结尾。