1.C语言数组的概念

在《更加优美的C语言输出》一节中我们举了一个例子，是输出一个 4×4 的整数矩阵，代码如下：
  1. #include <stdio.h>
    2. 

  2. #include <stdlib.h>
    3. 

  3. int main()
    4. 

  4. {
    5. 

  5.     int a1=20, a2=345, a3=700, a4=22;
    6. 

  6.     int b1=56720, b2=9999, b3=20098, b4=2;
    7. 

  7.     int c1=233, c2=205, c3=1, c4=6666;
    8. 

  8.     int d1=34, d2=0, d3=23, d4=23006783;
    9. 

  9.     printf("%-9d %-9d %-9d %-9d\n", a1, a2, a3, a4);
    10. 

  10.     printf("%-9d %-9d %-9d %-9d\n", b1, b2, b3, b4);
    11. 

  11.     printf("%-9d %-9d %-9d %-9d\n", c1, c2, c3, c4);
    12. 

  12.     printf("%-9d %-9d %-9d %-9d\n", d1, d2, d3, d4);
    13. 

  13.     system("pause");
    14. 

  14.     return 0;
    15. 

  15. }


运行结果：
20        345       700       22
56720     9999      20098     2
233       205       1         6666
34        0         23        23006783
矩阵共有 16 个整数，我们为每个整数定义了一个变量，也就是 16 个变量。那么，为了减少变量的数量，让开发更有效率，能不能为多个数据定义一个变量呢？比如，把每一行的整数放在一个变量里面，或者把 16 个整数全部都放在一个变量里面。
 
我们知道，要想把数据放入内存，必须先要分配内存空间。放入4个整数，就得分配4个int类型的内存空间：
  1. int a[4];
这样，就在内存中分配了4个int类型的内存空间，共 4×4=16 个字节，并为它们起了一个名字，叫a。
 
我们把这样的一组数据的集合称为数组（Array），它所包含的每一个数据叫做数组元素（Element），所包含的数据的个数称为数组长度（Length），例如int a[4];就定义了一个长度为4的整型数组，名字是a。
 
数组中的每个元素都有一个序号，这个序号从0开始，而不是从我们熟悉的1开始，称为下标（Index）。使用数组元素时，指明下标即可，形式为：
  1. arrayName[index]

arrayName 为数组名称，index 为下标。例如，a[0] 表示第0个元素，a[3] 表示第3个元素。
 
接下来我们就把第一行的4个整数放入数组：
  1. a[0]=20;
    2. 

  2. a[1]=345;
    3. 

  3. a[2]=700;
    4. 

  4. a[3]=22;

这里的0、1、2、3就是数组下标，a[0]、a[1]、a[2]、a[3] 就是数组元素。
 
我们来总结一下数组的定义方式：
  1. dataType  arrayName[length];

dataType 为数据类型，arrayName 为数组名称，length 为数组长度。例如：
  1. float m[12];
    2. 

  2. char ch[9];

 
注意：
1) 数组中每个元素的数据类型必须相同，对于int a[4];，每个元素都必须为 int。
 
2) 数组下标必须是整数，取值范围为 0 ≥ index > length。
 
3) 数组是一个整体，它的内存是连续的，下面是int a[4];的内存示意图：
 

①.数组的初始化

 
上面的代码是先定义数组再给数组赋值，我们也可以在定义数组的同时赋值：
  1. int a[4] = {20, 345, 700, 22};

{ }中的值即为各元素的初值，各值之间用,间隔。
 
对数组赋初值需要注意以下几点：
1) 可以只给部分元素赋初值。当{ }中值的个数少于元素个数时，只给前面部分元素赋值。例如：
  1. int a[10]={12, 19, 22 , 993, 344};

表示只给 a[0]~a[4] 5个元素赋值，而后面5个元素自动赋0值（int 类型变量的默认值就是0）。
 
2) 只能给元素逐个赋值，不能给数组整体赋值。例如给十个元素全部赋1值，只能写为：
  1. int a[10]={1, 1, 1, 1, 1, 1, 1, 1, 1, 1};

而不能写为：
  1. int a[10]=1;

3) 如给全部元素赋值，那么在数组定义时可以不给出数组的长度。例如：
  1. int a[]={1,2,3,4,5};

等价于
  1. int a[5]={1,2,3,4,5};

 
最后，我们借助数组来输出一个 4×4 的矩阵：
  1. #include <stdio.h>
    2. 

  2. #include <stdlib.h>
    3. 

  3. int main()
    4. 

  4. {
    5. 

  5.     int a[4] = {20, 345, 700, 22};
    6. 

  6.     int b[4] = {56720, 9999, 20098, 2};
    7. 

  7.     int c[4] = {233, 205, 1, 6666};
    8. 

  8.     int d[4] = {34, 0, 23, 23006783};
    9. 

  9.     printf("%-9d %-9d %-9d %-9d\n", a[0], a[1], a[2], a[3]);
    10. 

  10.     printf("%-9d %-9d %-9d %-9d\n", b[0], b[1], b[2], b[3]);
    11. 

  11.     printf("%-9d %-9d %-9d %-9d\n", c[0], c[1], c[2], c[3]);
    12. 

  12.     printf("%-9d %-9d %-9d %-9d\n", d[0], d[1], d[2], d[3]);
    13. 

  13.     system("pause");
    14. 

  14.     return 0;
    15. 

  15. }

2.C语言二维数组

上节讲解的数组可以看作是一行连续的数据，只有一个下标，称为一维数组。在实际问题中有很多量是二维的或多维的，因此C语言允许构造多维数组。多维数组元素有多个下标，以确定它在数组中的位置。本节只介绍二维数组，多维数组可由二维数组类推而得到。

①.二维数组的定义

 
二维数组定义的一般形式是：
  1. dataType arrayName[length1][length2];

其中，dataType 为数据类型，arrayName 为数组名，length1 为第一维下标的长度，length2 为第二维下标的长度。例如：
  1. int a[3][4];

定义了一个3行4列的数组，共有3×4=12个元素，数组名为a，即：
  1. a[0][0], a[0][1], a[0][2], a[0][3]
    2. 

  2. a[1][0], a[1][1], a[1][2], a[1][3]
    3. 

  3. a[2][0], a[2][1], a[2][2], a[2][3]

 
在二维数组中，要定位一个元素，必须给出一维下标和二维下标，就像在一个平面中确定一个点，要知道x坐标和y坐标。例如，a[3][4] 表示a数组第3行第4列的元素。
 
二维数组在概念上是二维的，但在内存中地址是连续的，也就是说存储器单元是按一维线性排列的。那么，如何在一维存储器中存放二维数组呢？有两种方式：一种是按行排列， 即放完一行之后顺次放入第二行。另一种是按列排列， 即放完一列之后再顺次放入第二列。
 
在C语言中，二维数组是按行排列的。也就是先存放a[0]行，再存放a[1]行，最后存放a[2]行；每行中的四个元素也是依次存放。数组a为int类型，每个元素占用4个字节，整个数组共占用4×(3×4)=48个字节。
 
【示例】一个学习小组有5个人，每个人有三门课的考试成绩。求全组分科的平均成绩和各科总平均成绩。
-- 张
 王 李 赵 周
Math 80 61 59 85 76
C 75 65 63 87 77
English 92 71 70 90 85
可设一个二维数组a[5][3]存放五个人三门课的成绩。再设一个一维数组v[3]存放所求得各分科平均成绩，设变量average 为全组各科总平均成绩。编程如下：
  1. #include <stdio.h>
    2. 

  2. int main(){
    3. 

  3.     int i, j;  //二维数组下标
    4. 

  4.     int sum=0;  //当前科目的总成绩
    5. 

  5.     int average;  //总平均分
    6. 

  6.     int v[3];  //各科平均分
    7. 

  7.     int a[5][3];  //用来保存每个同学各科成绩的二维数组
    8. 

  8.     printf("Input score:\n");
    9. 

  9.     for(i=0; i<3; i++){
    10. 

  10.         for(j=0; j<5; j++){
    11. 

  11.             scanf("%d", &a[j][i]);  //输入每个同学的各科成绩
    12. 

  12.             sum+=a[j][i];  //计算当前科目的总成绩
    13. 

  13.         }
    14. 

  14.         v[i]=sum/5;  // 当前科目的平均分
    15. 

  15.         sum=0;
    16. 

  16.     }
    17. 

  17.     average =(v[0]+v[1]+v[2])/3;
    18. 

  18.     printf("Math: %d\nC Languag: %d\nEnglish: %d\n", v[0], v[1], v[2]);
    19. 

  19.     printf("Total:%d\n", average);
    20. 

  20.     return 0;
    21. 

  21. }

运行结果：
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]，按行分段赋值可写为：
  1. int a[5][3]={ {80,75,92}, {61,65,71}, {59,63,70}, {85,87,90}, {76,77,85} };

按行连续赋值可写为：
  1. int a[5][3]={80, 75, 92, 61, 65, 71, 59, 63, 70, 85, 87, 90, 76, 77, 85};

这两种赋初值的结果是完全相同的。
 
【示例】求各科平均分和总成绩平均分。
  1. #include <stdio.h>
    2. 

  2. int main(){
    3. 

  3.     int i, j;  //二维数组下标
    4. 

  4.     int sum=0;  //当前科目的总成绩
    5. 

  5.     int average;  //总平均分
    6. 

  6.     int v[3];  //各科平均分
    7. 

  7.     int a[5][3]={ {80,75,92}, {61,65,71}, {59,63,70}, {85,87,90}, {76,77,85} };
    8. 

  8.     for(i=0; i<3; i++){
    9. 

  9.         for(j=0; j<5; j++){
    10. 

  10.             sum+=a[j][i];  //计算当前科目的总成绩
    11. 

  11.         }
    12. 

  12.         v[i]=sum/5;  // 当前科目的平均分
    13. 

  13.         sum=0;
    14. 

  14.     }
    15. 

  15.     average =(v[0]+v[1]+v[2])/3;
    16. 

  16.     printf("Math: %d\nC Languag: %d\nEnglish: %d\n", v[0], v[1], v[2]);
    17. 

  17.     printf("Total:%d\n", average);
    18. 

  18.     return 0;
    19. 

  19. }

运行结果：
Math: 72
C Languag: 73
English: 81
Total:75
 
对于二维数组初始化赋值还有以下说明
 
1) 可以只对部分元素赋初值，未赋初值的元素自动取0值。例如：
  1. int a[3][3]={{1},{2},{3}};

是对每一行的第一列元素赋值，未赋值的元素取0值。 赋值后各元素的值为：
1  0  0
2  0  0
3  0  0
 
  1. int a [3][3]={{0,1},{0,0,2},{3}};

赋值后的元素值为：
0  1  0
0  0  2
3  0  0
 
2) 如对全部元素赋初值，则第一维的长度可以不给出。例如：
  1. int a[3][3]={1,2,3,4,5,6,7,8,9};

可以写为：
  1. 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]。必须强调的是，a[0], a[1], a[2]不能当作下标变量使用，它们是数组名，不是一个单纯的下标变量。

3.C语言字符数组和字符串

用来存放字符的数组称为字符数组，例如：
  1. char c[10];

由于char和int可以相互转换，也可以定义为：
  1. int c[10];

但这时每个数组元素占4个字节的内存。
 
字符数组也可以是二维或多维数组。例如：
  1. char c[5][10];

字符数组也允许在定义时进行初始化，例如：
  1. char c[10]={'c', '  ', 'p', 'r', 'o', 'g', 'r', 'a','m'};  // c[9]未赋值，所以为默认值0

当对全体元素赋初值时也可以省去长度说明。例如：
  1. char c[]={'c', ' ', 'p', 'r', 'o', 'g', 'r', 'a', 'm' };

这时c数组的长度自动定为9。
 
字符数组和普通数组一样，也是通过下标引用各个元素。
 
【示例】输出字符数组中的元素。
  1. #include <stdio.h>
    2. 

  2. int main(){
    3. 

  3.     int i,j;
    4. 

  4.     char a[][7]={
    5. 

  5.         {'C',' ','L','a','n','g'},
    6. 

  6.         {'P','r','o','g','r','a','m'},
    7. 

  7.         {'F','u','n','n','y'}
    8. 

  8.     };
    9. 

  9.     for(i=0; i<=2; i++){
    10. 

  10.         for(j=0; j<=6; j++){
    11. 

  11.             printf("%c", a[i][j]);
    12. 

  12.         }
    13. 

  13.         printf("\n");
    14. 

  14.     }
    15. 

  15.     return 0;
    16. 

  16. }

运行结果：
C Lang
Program
Funny
 
本例的二维字符数组由于在初始化时全部元素都赋以初值，因此一维下标的长度可以不写。

①.字符串和字符串结束标志

 
在C语言中没有专门的字符串变量，没有string类型，通常用一个字符数组来存放一个字符串。
 
前面已经教大家用puts和printf函数输出字符串，例如：
  1. puts("http://c.biancheng.net");
    2. 

  2. printf("C Language");

在C语言中，字符串总是以'\0'作为串的结束符。上面的两个字符串，编译器已经在末尾自动添加了'\0'。
'\0'是ASCII码表中的第0个字符，用NUL表示，称为空字符。该字符既不能显示，也不是控制字符，输出该字符不会有任何效果，它在C语言中仅作为字符串的结束标志。
字符串处理函数遇到NUL时会认为字符串已经结束，不再继续操作，例如：
  1. #include <stdio.h>
    2. 

  2. int main(){
    3. 

  3.     puts("C Lang\0 is funny!");
    4. 

  4.     return 0;
    5. 

  5. }

运行结果：
C Lang
 
可以发现，'\0' 后面的字符都没有输出。
 
当把字符串存入字符数组时，也应该把结束符 '\0' 存入数组，并以此作为该字符串是否结束的标志。有了'\0'标志后，就不必再用字符数组的长度来判断字符串的长度了。
 
C语言允许用字符串的方式对数组作初始化赋值。例如：
  1. char c[]={'c', ' ','p','r','o','g','r','a','m'};

可写为：
  1. char c[]={"C program"};

或去掉{}写为：
  1. char c[]="C program";

 
用字符串方式赋值比用字符逐个赋值要多占一个字节， 用于存放字符串结束标志 '\0'。上面的数组c在内存中的实际存放情况为：

 
'\0' 是由编译器自动加上的。由于采用了 '\0' 标志，所以在用字符串赋初值时一般无须指定数组的长度， 而由编译器自行处理。

②.字符数组的输入输出

 
在采用字符串方式后，字符数组的输入输出将变得简单方便。除了上述用字符串赋初值的办法外，还可用printf函数和scanf函数一次性输出输入一个字符数组中的字符串，而不必使用循环语句逐个地输入输出每个字符。
 
【示例】使用printf输出整个字符数组。
  1. #include <stdio.h>
    2. 

  2. int main(){
    3. 

  3.     char c[]="C Lang\nJava\nC++\nPython";
    4. 

  4.     printf("%s\n", c);
    5. 

  5.     return 0;
    6. 

  6. }

运行结果：
C Lang
Java
C++
Python
 
在printf函数中，使用%s输出字符串。注意在输出列表中给出数组名即可。不能写为printf("%s", c[]);。
 
【示例】使用scanf从控制台输入一个字符串，然后使用printf将其输出。
  1. #include <stdio.h>
    2. 

  2. int main(){
    3. 

  3.     char str[100];  //必须说明长度，不能写为 char str[];
    4. 

  4.     printf("Input string: ");
    5. 

  5.     scanf("%s", str);
    6. 

  6.     printf("Your string is: %s\n", str);
    7. 

  7.     return 0;
    8. 

  8. }

运行结果：
Input string: http://c.biancheng.net↙
Your string is: http://c.biancheng.net
 
由于字符数组长度为100，因此输入的字符串长度必须小于100，以留出一个字节用于存放字符串结束标志`\0`。

③对程序的几点说明

 
1) 对一个字符数组，如果不作初始化赋值，则必须说明数组长度。
 
2) 当用scanf函数输入字符串时，字符串中不能含有空格，否则将以空格作为串的结束符。
 
例如当输入的字符串中含有空格时，运行结果为：
Input string: c language↙
Your string is: c
 
可以看出，空格以后的字符都未能输出。为了避免这种情况，可多设几个字符数组分段存放含空格的串。程序可改写如下：
  1. #include <stdio.h>
    2. 

  2. int main(){
    3. 

  3.     char str1[20], str2[20], str3[20], str4[20];
    4. 

  4.     printf("Input string: ");
    5. 

  5.     scanf("%s %s %s %s",str1, str2, str3, str4);
    6. 

  6.     printf("Your string: %s %s %s %s\n", str1, str2, str3, str4);
    7. 

  7.     return 0;
    8. 

  8. }

运行结果：
Input string: C C++ Java Python
Your string: C C++ Java Python
 
3) 在《从键盘输入数据》中讲到，scanf 的各个变量前面要加取地址符&，用以获得变量的地址，例如：
  1. int a, b;
    2. 

  2. scanf("%d %d", &a, &b);

但是在本节的示例中，将字符串读入字符数组却没有使用&，例如：
  1. char str1[20], str2[20], str3[20], str4[20];
    2. 

  2. scanf("%s %s %s %s",str1, str2, str3, str4);

这是因为C语言规定，数组名就代表了该数组的地址。整个数组是一块连续的内存单元，如有字符数组char c[10]，在内存可表示为：
 
C语言还规定，数组名所代表的地址为第0个元素的地址，例如char c[10];，c就代表c[0]的地址。第0个元素的地址就是数组的起始地址，所以称为首地址。也就是说，数组名表示数组的首地址。
 
设数组c的首地址为0X2000，也就是说c[0]地址为0X2000，则数组名c就代表这个首地址。
 
因为c已经表示地址，所以在c前面不能再加取地址符&，例如写作 scanf("%s",&c); 是错误的。
 
有了首地址，有了字符串结束符'\0'，就可以完整的定位一个字符串了。例如：
  1. printf("%s", c);

printf 函数会根据数组名找到c的首地址，然后逐个输出数组中各个字符直到遇到 '\0' 为止。
int、float、char 类型的变量表示数据本身，数据就保存在变量中；而数组名表示的是数组的首地址，数组保存在其他内存单元，数组名保存的是这块内存的首地址。后面我们会讲解指针，大家将会有更加深刻的理解。

4.C语言字符串处理函数

C语言提供了丰富的字符串处理函数，例如字符串的输入、输出、合并、修改、比较、转换、复制、搜索等，使用这些现成的函数可大大减轻编程的负担。
 
用于输入输出的字符串函数，例如printf、puts、scanf、gets等，使用时应包含头文件stdio.h，使用其它字符串函数则应包含头文件string.h。

①.字符串输入输出函数

 
printf、puts、scanf 前面已经介绍过了，不再赘述，这里重点讲解gets函数。
 
gets 是 get string 的缩写，意思是获取用户从键盘输入的字符串，语法格式为：
gets(arrayName);
arrayName 为字符数组。从键盘获得的字符串，将保存在 arrayName 中。请看下面的例子：
  1. #include <stdio.h>
    2. 

  2. int main(){
    3. 

  3.     char str[60];
    4. 

  4.     printf("Input string: ");
    5. 

  5.     gets(str);
    6. 

  6.     puts(str);
    7. 

  7.     return 0;
    8. 

  8. }

运行结果：
Input string: C Java C++ Python
C Java C++ Python
 
可以看出当输入的字符串中含有空格时，输出仍为全部字符串。说明 gets 函数并不以空格作为字符串输入结束的标志，而只以回车作为输入结束，这与 scanf 函数是不同的。

②.字符串长度函数strlen

 
strlen 是 string length 的缩写，用来获得字符串的长度。所谓长度，就是包含多少个字符（不包括字符串结束标志 '\0'）。语法格式为：
  1. strlen(arrayName);

strlen 将返回字符串的长度，它是一个整数。请看下面的例子：
  1. #include <stdio.h>
    2. 

  2. #include <string.h>
    3. 

  3. int main(){
    4. 

  4.     char str[]="C language";
    5. 

  5.     int len = strlen(str);
    6. 

  6.     printf("The lenth of the string is %d\n", len);
    7. 

  7.     return 0;
    8. 

  8. }

运行结果：
The lenth of the string is 10
 
需要说明的是，strlen 会从字符串的第 0 个字符开始计算，直到遇到字符串结束标志 '\0'。将上面代码中的 str 改为：
  1. char str[]="C \0language";

那么输出结果就是：
The lenth of the string is 2

③.字符串连接函数 strcat

 
strcat 是 string catenate 的缩写，意思是把两个字符串拼接在一起，语法格式为：
  1. strcat(arrayName1, arrayName2);

arrayName1、arrayName2 为需要拼接的字符串。
 
strcat 将把 arrayName2 连接到 arrayName1 后面，并删去 arrayName1 最后的结束标志 '\0'。这就意味着，arrayName1 的长度要足够，必须能够同时容纳 arrayName1 和 arrayName2，否则会越界。
 
strcat 返回值为 arrayName1 的首地址。请看下面的例子：
  1. #include <stdio.h>
    2. 

  2. #include <string.h>
    3. 

  3. int main(){
    4. 

  4.     char str1[40]="My name is ";
    5. 

  5.     int str2[20];
    6. 

  6.     printf("Input your name:");
    7. 

  7.     gets(str2);
    8. 

  8.     strcat(str1,str2);
    9. 

  9.     puts(st1);
    10. 

  10.     return 0;
    11. 

  11. }

运行结果：
Input your name:xiao p
My name is xiao p

④.字符串复制函数strcpy

 
strcpy 是 string copy 的缩写，意思是字符串复制，语法格式为：
  1. strcpy(arrayName1, arrayName2);

strcpy 会把 arrayName2 中的字符串拷贝到 arrayName1 中，串结束标志 '\0' 也一同拷贝。arrayName 也可以是一个字符串常量，这时相当于把一个字符串赋值给一个字符数组。请看下面的例子：
  1. #include <stdio.h>
    2. 

  2. #include <string.h>
    3. 

  3. int main(){
    4. 

  4.     char str1[15], str2[]="C Language";
    5. 

  5.     strcpy(str1, str2);
    6. 

  6.     puts(str1);
    7. 

  7.     printf("\n");
    8. 

  8.     return 0;
    9. 

  9. }

运行结果：
C Language
 
strcat 要求 arrayName1 要有足够的长度，否则不能全部装入所拷贝的字符串。

5.对C语言数组的总结以及实例

数组（Array）是一系列相同类型的数据的集合，可以是一维的、二维的、多维的；最常用的是一维数组和二维数组，多维数组较少用到。

①.对数组的总结

 
1) 数组的定义格式为：
  1. type arrayName[length]

type 为数据类型，arrayName 为数组名，length 为数组长度。
需要注意的是：
  1. length 必须是一个数值常量，不能是变量，因为代码编译期间编译器要明确知道数组元素的个数，而变量的值是不确定的。
  2. 数组中的数据保存在一个内存区域A，而数组名保存另外一个内存区域B，数组名中包含的是A的首地址。
 
2) 访问数组中某个元素的格式为：

index 为数组下标。
注意 index 的值不能大于 length，否则会发生数组越界，出现意想不到的错误。
 
3) 可以对数组中的单个元素赋值，也可以整体赋值，例如：
  1. // 对单个元素赋值
    2. 

  2. int a[3];
    3. 

  3. a[0] = 3;
    4. 

  4. a[1] = 100;
    5. 

  5. a[2] = 34;
    6. 

  6. // 整体赋值（不指明数组长度）
    7. 

  7. float b[] = { 23.3, 100.00, 10, 0.34 };
    8. 

  8. // 整体赋值（指明数组长度）
    9. 

  9. int m[10] = { 100, 30, 234 };
    10. 

  10. // 字符数组赋值
    11. 

  11. char str[] = "http://c.biancheng.net";

对数组整体赋值时，可以不指名数组的长度。未赋值的元素为默认值。

②.数组应用举例

 
求一个整型数组中的最大值和最小值。
  1. #include <stdio.h>
    2. 

  2. int main(){
    3. 

  3.     int a[10] = {2, 123, 45, 100, 575, 240, 799, 710, 10, 90};
    4. 

  4.     int max=a[0], min=a[0];  //最大值和最小值
    5. 

  5.     int i;  //循环增量
    6. 

  6.     int len = sizeof(a) / sizeof(int);  //计算数组长度
    7. 

  7.     for(i=1; i<len; i++){
    8. 

  8.         if(a[i] > max){
    9. 

  9.             max = a[i];
    10. 

  10.         }
    11. 

  11.         if(a[i] < min){
    12. 

  12.             min = a[i];
    13. 

  13.         }
    14. 

  14.     }
    15. 

  15.     printf("The max is %d, The min is %d\n", max, min);
    16. 

  16.     return 0;
    17. 

  17. }

运行结果：
The max is 799, The min is 2
 
思考一下，max 和 min 的初值为什么要设为 a[0] 呢，默认不可以吗？
 

③.关于排序和查找

 
学完了数组，有两个重要的知识点要求大家掌握，那就是排序（Sort）和查找（Search），比如：
  1. 给你 10 个打乱顺序的整数，要能够按照从小到大或者从大到小的顺序输出；
  2. 给定一个字符串 str1，以及一个子串 str2，要能够判断 str2 是否在 str1 中。
 


C语言数组：C语言数组定义、二维数组、动态数组、字符串数组的更多相关文章

  1. Android 在资源文件（res/strings.xml）定义一维数组，间接定义二维数组

    经常我们会在资源文件(res/strings.xml)定义字符串,一维数组,那定义二维数组?直接定义二维数组没找到,可以间接定义. 其实很简单,看过用过一次就可以记住了,一维数组估计大家经常用到,但是 ...

  2. JavaScript -- 定义二维数组

    方法一:直接定义并且初始化,这种遇到数量少的情况可以用var _TheArray = [["0-1","0-2"],["1-1"," ...

  3. 【转】java中定义二维数组的几种写法

    原文链接 注:以下的 type[][] var 也可以这样申明 type var[][] type为数组的类型,var为变量名 写法一:行列固定的数组 //定义二维数组写法1 class Test { ...

  4. c指针与数组，传参问题，指针数组与数组指针的区别，二维数组动态内存分配

    一 数组的结构:顺序存储,看谭浩强中的图,牢记 1.数组名指代一种数据结构:数组 现在可以解释为什么第1个程序第6行的输出为10的问题,根据结论1,数组名str的内涵为一种数据结构,即一个长度为10的 ...

  5. java 数组基础学习（一维二维数组）

    1.一维数组 1>静态初始化:数据类型[ ] 变量名 = {元素} 例:int[ ] arr = {1,2} 动态初始化:数据类型[ ] 变量名 = new数据类型[数据长度] 例:int[ ] ...

  6. C语言malloc函数为一维，二维，三维数组分配空间

    c语言允许建立内存动态分配区域,以存放一些临时用的数据,这些数据不必在程序的声明部分定义,也不必等到函数结束时才释放,而是需要时随时开辟,不需要时随时释放,这些数据存储在堆区.可以根据需要,向系统申请 ...

  7. 【C语言入门教程】4.2 二维数组

    C 语言允许使用多维数组,即使用多组小标的数组,二维数组是最常用的多维数组.多维数组在内存中存放数据的顺序与一维数组相同,使用连续的存储单元. 4.2.1 二维数组的一般形式 二维数组的一般声明形式为 ...

  8. C语言程序，找出一个二维数组的鞍点。

    什么是鞍点????? 鞍点就是在一个二维数组中,某一个数在该行中最大,然而其在该列中又是最小的数,这样的数称为鞍点. 昨天突然在书上看到这样的一道题,就自己尝试着写了一个找出一个二维数组中的鞍点. 好 ...

  9. c语言题目：找出一个二维数组的“鞍点”，即该位置上的元素在该行上最大，在该列上最小。也可能没有鞍点

    //题目:找出一个二维数组的“鞍点”,即该位置上的元素在该行上最大,在该列上最小.也可能没有鞍点. // #include "stdio.h" #include <stdli ...

  10. 【C语言】构造长度可变的二维数组

    #include <stdio.h> #include <malloc.h> #include <memory.h> int getArray(int ***p,i ...

随机推荐

  1. php通过cURL下载网络上面的一个HTTPS的资源

    <?php /** * php通过cURL下载网络上面的一个HTTPS的资源 * 案例:从google的CDN上下载jquery- v1.7.1 */ $curlobj = curl_init( ...

  2. Java程序设计---io流读取文件内容并将其逆值输出到控制台

    import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.File;import java.io.FileR ...

  3. Python读入CIFAR-10数据库

    CIFAR-10可以去http://www.cs.toronto.edu/~kriz/cifar.html下载(记得下载python格式) CIFAR-10数据组成: 训练集和测试集分别有50000和 ...

  4. window.onload的加载和$(document).read()

    1.执行时机: window.onload :必须等到网页中所有的内容加载完之后才执行. $(document).read():网页中所有的DOM结构执行完毕后.可能DOM元素并未加载完. 2.单个网 ...

  5. C# 校验帮助类-正则表达式

    一.简介 很多时候我们都需要用到一些验证的方法,有时候需要用正则表达式校验数据时,往往需要到网上找很久,结果找到的还不是很符合自己想要的.所以我把自己整理的校验帮助类分享处理,在这里分享一下,给自己留 ...

  6. LINQ TO SQL和Entity Framework 的关系 你了解多少？

    1. LINQ  TO SQL  和EF 特点:  LINQ TO SQL和Entity Framework都是一种包含LINQ功能的ORM 也就是所谓的关系对象的映射.其中包括的有DBFrist   ...

  7. tp5实现邮件发送

    项目中,用户修改密码,需要发送验证码到用户邮箱,于是就看了看,在此记录一下. 1.开启SMTP服务 测试用的是自己的qq邮箱,首先需要开启邮箱的SMTP服务,开启之后,要记得给你的授权码,授权码一定要 ...

  8. Python-Flask：利用flask_sqlalchemy实现分页效果

    Flask-sqlalchemy是关于flask一个针对数据库管理的.文中我们采用一个关于员工显示例子. 首先,我们创建SQLALCHEMY对像db. from flask import Flask, ...

  9. gulp静态资源构建、压缩、版本号添加

    公司移动端商城使用前后分离方案,前台nginx静态文件,js使用requirejs模式,使用gulp压缩添加版本号时发现问题, 问题1.在公共的js配置中,引用的路径是写死的,缓存会一直存在. 解决方 ...

  10. JS - 实现简单易用的倒计时 x 天 x 时 x 分 x 秒

    <script> (function () { var tian = document.getElementsByClassName('JS-tian')[0]; var shi = do ...