前言

　数组（Array）就是一些列具有相同类型的数据的集合，这些数据在内存中依次挨着存放，彼此之间没有缝隙。一个数组可以分解为多个数组元素，这些数组元素可以是基本数据类型或是构造类型。
　因此按数组元素的类型不同，数组又可分为数值数组、字符数组、指针数组、结构数组等各种类别，本节我们不探索指针数组，结构数组。

　当需要定义或者存储多个数据类型相同的变量，同时希望这些变量可以在计算机中连续存储，以便于处理，于是就产生了数组。

引例

当我们需要存储一个矩阵时，我们需要定义很多变量来进行存储，例如：

#include <stdio.h>
int main()
{
    int a1=1, a2=2, a3=3, a4=4;
    int b1=5, b2=6, b3=7, b4=8;
    int c1=9,c2=10, c3=11, c4=12;
    int d1=13,d2=14, d3=15, d4=16;

    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);

    return 0;
}


//运行结果
1         2         3         4        
5         6         7         8        
9         10        11        12       
13        14        15        16

　矩阵共有 16 个整数，我们为每个整数定义了一个变量，也就是 16 个变量。那么，为了减少变量的数量，让开发更有效率，能不能为多个数据定义一个变量呢？比如，把每一行的整数放在一个变量里面，或者把 16 个整数全部都放在一个变量里面。答案当然是肯定的，办法就是使用数组（Array）。

一维数组

　当有一组类型相同的变量需要顺序存放到内存中时，可以用一维数组实现，构成一个线性的列表，并且可以使用统一的名称进行索引不同的变量。看到上面的引例之后，我们来看一下一维数组的概念和定义。

一维数组的概念和定义

　一位数组的一般定义形式为：

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

eg：
  int a[4];//含义：定义了一个长度为4的整型数组，名字是a
  
  要想把数据放入内存，必须先要分配内存空间，那放入4个整数，就得分配4个int类型的内存空间.

定义：
　我们把这样的一组数据的集合称为数组（Array）
　所包含的每一个数据叫做数组元素（Element）
　所包含的数据的个数称为数组长度（Length）
　数组中的每个元素都有一个序号，这个序号从0开始，而不是从我们熟悉的1开始，称为下标（Index）。
　使用时，可以按照arrayName[index]的形式使用数组。（arrayName 为数组名称，index 为下标）
注意事项:

　不同于一般变量的定义，定义数组时有些特殊的规则:

定义数组应该遵循数组定义格式，类型说明符与数组名之间存在一个空格。

数组名与左中括号之间不能有空格。

数组长度 length 最好是整数或者常量表达式，例如 10、204 等，这样在所有编译器下都能运行通过；如果 length 中包含了变量，例如 n、4m 等，在某些编译器下就会报错

常量表达式的值表示数组的长度，即表示数组共有多少个元素，一旦数组长度确定，就不能进行修改。

数组名不能与其他变量名重名。

数组中每个元素的数据类型必须相同，对于int a[4];，每个元素都必须为 int。

访问数组元素时，下标的取值范围为 0 ≤ index < length，过大或过小都会越界，导致数组溢出，发生不可预测的情况。

实例：

#include <stdio.h>
int main()
{
    int nums[10];
    int i;
   
    //从控制台读取用户输入
    for(i=0; i<10; i++)
    {
        scanf("%d", &nums[i]);  //注意取地址符 &，不要遗忘哦
        //scanf() 读取数据时需要一个地址（地址用来指明数据的存储位置），而 nums[i] 表示一个具体的数组元素，所以要在前边加 & 来获取地址
    }
   
    //依次输出数组元素
    for(i=0; i<10; i++)
    {
        printf("%d ", nums[i]);
    }
   
    return 0;
}

//运行结果：
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10

一位数组在内存中的存放方式

　数组是一个整体，在内存中是连续存放的，占据连续的内存单元，也就是说，数组元素之间是相互挨着的，彼此之间没有一点点缝隙。

例如：int a[4];在内存中的存放顺序为：

　数据类型不同，所占的内存字节数也不相同，但其各元素的存放是连续的。

　数组在内存中的所占的字节数为：

　数组内存字节数=数组元素数据类型所占字节数 * 数组长度

　「数组内存是连续的」这一点很重要，连续的内存为指针操作（通过指针来访问数组元素）和内存处理（整块内存的复制、写入等）提供了便利，这使得数组可以作为缓存（临时存储数据的一块内存）使用。

一维数组的赋值与引用

　数组一定要先定义后使用，并且在使用前需要对数组元素赋值，没有赋值的数组在引用时会使用内存中原有的随机值。

数组的下标越界引用

　众所邹知，数组需要在引用时使用数组下标来引用数组，例如：

int a[N];

则可以使用a[0],a[1],a[2],a[3],……,a[N-1]的数组元素。

从上面可以知道，数组下标最大为N-1，由于C语言并没有对数组进行下标越界检查，假设使用了>N的下标做引用，编译器会给出警告，但并不影响编译，因此，在编写程序时，我们需要非常注意数组的越界检查。

数组定义时赋初值

数组可以在定义时赋初始值，例如：

int a[4] = {20, 345, 700, 22};
数组定义时赋初值使用大括号将各元素的初始值进行封装，各个初始值之间用逗号分隔，即由{ }包围，各个值之间以,分隔。

需要注意的是，也可以不规定长度：
int a[] = {20, 345, 700, 22};
这种方式将数组长度默认为4.

数组赋初始值可以同时为所有元素赋值，也可以为部分元素赋初始值，当对部分元素赋初始值时，未被赋值的元素自动被置为0.

实例：

#include<stdio.h>

int main()
{
    int i;
    int a[10]={1,2,3,4,5};
    for(i=0;i<10;i++)
    {
        printf("%-3d",a[i]);
    }
    return 0;
}

运行结果：
1  2  3  4  5  0  0  0  0  0

与我们设想的完全一致

总结一下：

可以只给部分元素赋值。当{ }中值的个数少于元素个数时，只给前面部分元素赋值。例如：

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 即可。

只能给元素逐个赋值，不能给数组整体赋值。例如给 10 个元素全部赋值为 1，只能写作：

int a[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
而不能写作：
int a[10] = 1;

如给全部元素赋值，那么在定义数组时可以不给出数组长度。例如：

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

数组元素赋值

数组也可以先定义后赋值，但此时只能对某个元素赋值，而不能对整个数组赋值。

例如：

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

是错误的，C语言不支持对整个数组作为引用。

正确赋值为：

int a[5];
a[0]=1;
a[1]=2;
a[2]=3;
a[3]=4;
a[4]=5;

数组的输出

数组输出的只能按元素输出，而不能一次输出数组中所有的元素。

eg:

int a[3]={12,22,35};
printf("%d",a);

这样输出是非法的。

上述语句中试图使用数组名输出全部元素的值，C语言中，这样的操作是非法的。

正确的输出形式为：

printf("%d %d %d",a[0],a[1],a[2]);

数组首地址与数组元素地址

数组首地址是指该数组在内存中的起始地址位置，通常使用数组名表示数组首地址。

int a[10];

则数组a的首地址为a。

　数组元素的指各元素在内存中的位置，数组元素的地址要两种表达式，一中是使用地址操作符&，另一种是使用数组首地址偏移量(a+x)来表示，x可以用数组下标表示。数组的第一个元素地址与数组首地址相同。

若定义数组：

int a[5];

取地址符:&a[0],&a[1],&a[2],&a[3],&a[4];

地址偏移：a,a+0,a+1,a+2,a+3,a+4;

一位数组的应用：

　回到开头的那个例子：

#include <stdio.h>
int main()
{
    int a[4] = {1,2,3,4};
    int b[4] = {5,6,7,8};
    int c[4] = {9,10,11,12};
    int d[4] = {13,14,15,16};

    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;
}

输出结果:
1         2         3         4        
5         6         7         8        
9         10        11        12       
13        14        15        16

补充：


a[n]=*(a+n)
&a[n]=a+n

二维数组

二维数组定义

　在实际生活中，会经常使用到二维类型的数据，比如矩阵由行和列构成，二维数组的一般表达形式为:

dataType arrayName[length1][length2];
即
类型说明符 数组名[常量表达式1][常量表达式2];

dataType 为数据类型，arrayName 为数组名，length1 为第一维下标的长度，length2 为第二维下标的长度。
其中，类型说明符，数组名，常量表达式1与常量表达式2与一位数组

常量表达式和元素个数

　常量表达式1表示数组的第一维长度，常量表达式2表示数组的第二维长度。

　通常，将二维数组看成一个矩阵，第一维表示行，第二微表示列，因此也把第一维称为行标，第二维称为列标。数组元素的总数为：数组元素个数=行数*列数。

eg:

int a[2][3];
其中行为2，列为3，则数组a总共有元素2*3=6个。

二维数组的逻辑结构

　我们可以将二维数组看做一个 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 轴。

　二维数组在概念上是二维的，但在内存中是连续存放的；换句话说，二维数组的各个元素是相互挨着的，彼此之间没有缝隙。那么，如何在线性内存中存放二维数组呢？有两种方式：

一种是按行排列，即放完一行之后再放入第二行；
另一种是按列排列，即放完一列之后再放入第二列。

　在C语言中，二维数组是按行排列的。也就是先存放 a[0] 行，再存放 a[1] 行，最后存放 a[2] 行；每行中的 4 个元素也是依次存放。数组 a 为 int 类型，每个元素占用 4 个字节，整个数组共占用 4×(3×4)=48 个字节。

　你可以这样认为，二维数组是由多个长度相同的一维数组构成的。

二维数组的内存结构

　与二维数组的逻辑结构有所不同，二维数组在内存中是线性存储的，即在内存中将个元素连续存储。

eg：

int a[2][3];

定义了一个二维数组a，行数为2，列数为3，共2*3=6个元素。
C语言中，系统将二维数组按顺序将元素存放到内存中。
采用按行列排列的方式，即先排一行，然后再排第二行，以此类推。

实例分析：

一个学习小组有 5 个人，每个人有 3 门课程的考试成绩，求该小组各科的平均分和总平均分

--	Math	C	English
张	90	78	78
正华	65	43	98
丽丽	78	64	66
圈圈	53	84	80
梦	67	77	90

代码如下：

#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;
}

//分析：

程序使用了一个嵌套循环来读取所有学生所有科目的成绩。
在内层循环中依次读入某一门课程的各个学生的成绩，并把这些成绩累加起来，退出内层循环（进入外层循环）后再把该累加成绩除以 5 送入 v[i] 中，这就是该门课程的平均分。
外层循环共循环三次，分别求出三门课各自的平均成绩并存放在数组 v 中。
所有循环结束后，把 v[0]、v[1]、v[2] 相加除以 3 就可以得到总平均分。

二维数组的赋值与初始化

　二维数组的初始化可以按行分段赋值，也可按行连续赋值。

二维数组分段方式赋初值

　定义二维数组的同时也可以对数组各元素赋初值，定义赋初值可以使用按行分段方式对各行元素分别赋值：

eg:

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

可以不必指定所有元素的值，当有一部分数组元素被赋值时，后面的元素将自动赋值为0；

二维数组连续赋初值

　二维数组也可以按照连续赋值方式对所有元素赋值，数组使用大括号封装，各数组之间用逗号隔开。

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

也可以只对部分元素赋值，此时，未被赋值的部分将隐含赋值为0.

eg:
int a[2][4]={1,2,3,4};
则其余元素会被默认赋值为0；

举例小结

　对于数组 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};

这两种赋初值的结果是完全相同的。

二维数组元素赋值

若二维数组在定义是没有进行赋值，则只能在引用时分别对每个元素赋值，此时未被赋值的元素为不确定值。

eg:

int a[2][4];
a[0][0]=10;
a[1][3]=1;
则未被赋值的元素的值为随机值。

注意(attention):

不能试图使用数组名对整个元素赋值。b={{1,2,3},{4,5,6}}是错误的.

当定义数组后，再次对数组的操作除了字符数组外都是以元素为单位引用的。

二维数组定义之后，可以引用数组各元素进行赋值和引用等操作。二维数组的引用可以使用行标和列标实现，且行标和列标都是从0开始。

实例分析
　求各科的平均分和总平均分，要求在初始化数组的时候直接给出成绩。

--	Math	C	English
张	90	78	78
正华	65	43	98
丽丽	78	64	66
圈圈	53	84	80
梦	67	77	90

#include <stdio.h>
int main()
{
    int i, j;  //二维数组下标
    int sum = 0;  //当前科目的总成绩
    int average;  //总平均分
    int v[3];  //各科平均分
    int a[5][3] = {{90,78,78}, {65,43,98}, {78,64,66}, {53,84,80}, {67,77,90}};
    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;
}

重点分析：

对于二维数组的初始化还要注意以下几点：

可以只对部分元素赋值，未赋值的元素自动取“零”值。

例：

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

是对每一行的第一列元素赋值，未赋值的元素的值为 0。赋值后各元素的值为：

1  0  0
2  0  0
3  0  0

如果对全部元素赋值，那么第一维的长度可以不给出。

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};

二维数组可以看作是由一维数组嵌套而成的；如果一个数组的每个元素又是一个数组，那么它就是二维数组。当然，前提是各个元素的类型必须相同。

a[i][j]=*(*(a+i)+j)
&a[i][j]=(*(a+i)+j)

字符数组

字符数组的定义

　用于存储字符或者字符串的数组成为字符数组，和数据类型的数组类似，字符数组也可以定义为一维数组和二维数组。

字符数组的定义

字符数组由关键字char来定义，其定义的一般形式为：

char 数组名[常量表达式];

其中，常量表达式和一维数组及二维数组的常量表达式规则相同，不能使用变量或者表达式，只能使用整型或结果为整型的表达式。

用来存放字符的数组称为字符数组

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类型，通常就用一个字符数组来存放一个字符串。

字符数组的辅助与引用

定义赋初值
　字符数组定义时可以按照给每个元素赋初值，其中数值部分使用大括号封装，各字符间使用逗号隔开。以这种赋值方式定义的数组也可以不指定数组长度，即常量表达式可以省略，此时，系统默认字符数组长度为大括号内字符个数。

例如：

char test[8]={'Y','o','u','A','n','d','M','e'};

部分元素赋初值

在定义字符数组是也可以对部分元素赋初值，此时，未被赋初值部分将被赋值为0，字符为空格。

例如：

char test[8]={'S','o','m','e'};

数组元素赋值与引用

　当定义字符数组后，可以对每个元素进行赋值操作，此时也称为对数组元素的引用。数组元素引用时，数组下标不能越界。

char a[5];
a[0]='l';
a[1]='u';
a[2]='c';
a[3]='k';
a[4]='y';

注意，不能使用字符数组名对所有元素一次性赋值。

字符数组与字符串

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 a[常量表达式]="字符串内容";

其中，字符串使用双引号封装，常量表达式应该大于字符串内容字符串字数+1，即：常量表达式>=sizeof(字符串内容)+1，原因是因为字符串在内存中存储时会在其他自动自动添加结束符'\0',作为隐含字符添加到字符数组中.(后面会具体讲到)

字符串的输入与输出

字符串的输入

可以采用%s格式将字符串输入到字符数组中，此时一定要注意，系统将空格,\0,和回车全部作为字符串结束标志处理.

注意：这里使用scanf函数用%s读取字符串时，对字符串数组不需要加取地址符，数组名本身就是一个地址常量，因此不需要添加取地址符.

字符串输出

使用字符串对字符数组赋初始值后，可以使用格式控制符%s输出字符串,使用%s格式输出字符串，程序会遇到'\0'结束输出.

注意：定义时不要输入超过字符串数组长度的字符串，由于C语言不对数组越界进行检查，所以可能会造成内存溢出的现象，编程时应该尽量避免这种事情的发生。

字符串结束标志

　字符串是一系列连续的字符的组合，要想在内存中定位一个字符串，需要知道字符串的开头和结尾。找到字符串的开头很容易，知道名字（字符数组名或者字符串名）即可；然而，如何找到字符串的结尾呢？

　在C语言中，字符串总是以'\0'作为结尾，所以'\0'也被称为字符串结束标志，或者字符串结束符。
'\0'是 ASCII 码表中的第 0 个字符，英文称为 NUL，中文称为“空字符”。
该字符既不能显示，也没有控制功能，输出该字符不会有任何效果，它在C语言中唯一的作用就是作为字符串结束标志。

我们给出的重点如下：

C语言在处理字符串时，会从前往后逐个扫描字符，一旦遇到'\0'就认为到达了字符串的末尾，就结束处理。
'\0'至关重要，没有'\0'就意味着永远也到达不了字符串的结尾。
由" "包围的字符串会自动在末尾添加'\0'。

eg:

"C program"

逐个字符地给数组赋值并不会自动添加'\0'

eg:

char s[] = {'a', 'b', 'c'};

数组 s 的长度为 3，而不是 4，因为最后没有'\0'

当用字符数组存储字符串时，要特别注意'\0'，要为'\0'留个位置；这意味着，字符数组的长度至少要比字符串的长度大 1。
当字符串长度大于数组长度时，有些较老或者不严格的编译器并不会报错，甚至连警告都没有，这就为以后的错误埋下了伏笔，读者自己要多多注意。

结合上述分析，我们给出这样一个例子

将 26 个大写英文字符存入字符数组，并以字符串的形式输出

程序1：

#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 ?

//口表示无法显示的特殊字符。

分析:
printf() 输出字符串时，会从第 0 个元素开始往后检索，直到遇见'\0'才停止
然后把'\0'前面的字符全部输出，这就是 printf() 输出字符串的原理。
本例使用 printf() 输出 str，按理说到了第 26 个元素就能检索到'\0'，就到达了字符串的末尾，
由于我们并未对最后 4 个元素赋值，所以第 26 个元素不是'\0'，第 27 个也不是，第 28 个也不是……可能到了第 50 个元素才遇到'\0'，
printf() 把这 50 个字符全部输出出来，就是上面的样子，多出来的字符毫无意义，甚至不能显示。

由于,在函数内部定义的变量、数组、结构体、共用体等都称为局部数据。在很多编译器下，局部数据的初始值都是随机的、无意义的，而不是我们通常认为的“零”值。所以,例中的 str 数组在定义完成以后并没有立即初始化，所以它所包含的元素的值都是随机的，只有很小的概率会是“零”值。循环结束以后，str 的前 26 个元素被赋值了，剩下的 4 个元素的值依然是随机的，不知道是什么。

要想避免这些问题也很容易，在字符串的最后手动添加'\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'）

在C语言中，string.h头文件中的 strlen() 函数来求字符串的长度，它的用法为：

length strlen(strname);

//分析
strname 是字符串的名字，或者字符数组的名字；length 是使用 strlen() 后得到的字符串长度，是一个整数。

#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.

end

构造数据类型之--数组

前言

引例