C语言数组和字符数组和字符串详解
我们知道，要想把数据放入内存，必须先要分配内存空间。放入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 的字符型数组
需要注意的是：
1) 数组中每个元素的数据类型必须相同，对于int a[4];，每个元素都必须为 int。
2) 数组长度 length 最好是整数或者常量表达式，例如 10、20*4 等，这样在所有编译器下都能运行通过；如果 length 中包含了变量，例如 n、4*m 等，在某些编译器下就会报错。
3) 访问数组元素时，下标的取值范围为 0 ≤ index < length，过大或过小都会越界，导致数组溢出，发生不可预测的情况。
数组内存是连续的
数组是一个整体，它的内存是连续的；也就是说，数组元素之间是相互挨着的，彼此之间没有一点点缝隙。下图演示了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; }
二维数组的定义、初始化、赋值
二维数组的定义
二维数组定义的一般形式是：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]
也可以将二维数组看成一个坐标系，有 x 轴和 y 轴，要想在一个平面中确定一个点，必须同时知道 x 轴和 y 轴。
二维数组在概念上是二维的，但在内存中是连续存放的；换句话说，二维数组的各个元素是相互挨着的，彼此之间没有缝隙。那么，如何在线性内存中存放二维数组呢？有两种方式：
- 一种是按行排列， 即放完一行之后再放入第二行；
- 另一种是按列排列， 即放完一列之后再放入第二列。
在C语言中，二维数组是按行排列的。也就是先存放 a[0] 行，再存放 a[1] 行，最后存放 a[2] 行；每行中的 4 个元素也是依次存放。数组 a 为 int 类型，每个元素占用 4 个字节，整个数组共占用 4×(3×4)=48 个字节。
你可以这样认为，二维数组是由多个长度相同的一维数组构成的。
【实例1】一个学习小组有 5 个人，每个人有 3 门课程的考试成绩，求该小组各科的平均分和总平均分。
| -- | Math | C | English |
| aa | 80 | 75 | 92 |
| bb | 61 | 65 | 71 |
| cc | 59 | 63 | 70 |
| dd | 85 | 87 | 90 |
| ee | 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]。
字符数组
用来存放字符的数组称为字符数组，例如：
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' }; //对全体元素赋值时可以省去长度
C语言规定，可以将字符串直接赋值给字符数组，例如：
char str[30] = {"c.biancheng.net"};
char str[30] = "c.biancheng.net"; //这种形式更加简洁，实际开发中常用
'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语言中唯一的作用就是作为字符串结束标志。'\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; }
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; }
'\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; }
字符串长度
所谓字符串长度，就是字符串包含了多少个字符（不包括最后的结束符'\0'）。例如"abc"的长度是 3，而不是 4。在C语言中，我们使用
string.h头文件中的 strlen() 函数来求字符串的长度，它的用法为：
length strlen(strname);
strname 是字符串的名字，或者字符数组的名字；length 是使用 strlen() 后得到的字符串长度，是一个整数。下面是一个完整的例子，它输出http://c.biancheng.net/c/网址的长度：
#include <stdio.h> #include <string.h> //记得引入该头文件 int main(){ char str[] = "http://c.biancheng.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.
浙公网安备 33010602011771号