C语言拾遗-C语言数据类型-数组

数组(Array)就是一些具有相同类型的数据的集合,这些数据在内存中依次挨着存放,彼此之间没有缝隙。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] 就是数组元素。

数组内存是连续的

数组是一个整体,它的内存是连续的;也就是说,数组元素之间是相互挨着的,彼此之间没有一点点缝隙。连续的内存为指针操作(通过指针来访问数组元素)和内存处理(整块内存的复制、写入等)提供了便利,这使得数组可以作为缓存(临时存储数据的一块内存)使用。

数组的初始化

上面的代码是先定义数组再给数组赋值,我们也可以在定义数组的同时赋值,例如:

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。

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

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

等价于

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

二维数组

上述数组可以看作是一行连续的数据,只有一个下标,称为一维数组。在实际问题中有很多数据是二维的或多维的,因此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]。

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

  • 一种是按行排列, 即放完一行之后再放入第二行;
  • 另一种是按列排列, 即放完一列之后再放入第二列。

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

二维数组的初始化

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

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

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

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

1,可以只对部分元素赋值,未赋值的元素自动取“零”值。例如:

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

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

1  0  0
2  0  0
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]。

静态数组

在C语言中,数组一旦被定义后,占用的内存空间就是固定的,容量就是不可改变的,既不能在任何位置插入元素,也不能在任何位置删除元素,只能读取和修改元素,我们将这样的数组称为静态数组。反过来说,如果数组在定义后可以改变容量,允许在任意位置插入或者删除元素,那么这样的数组称为动态数组。

C语言数组为什么是静态的

数组元素都是紧挨着排布的,中间没有空隙,不管是插入元素还是删除元素,都得移动该元素后面的内存:

  • 在第 i 个元素后面插入一个新元素时,第 i 个元素后面的所有元素都要往后移动一个元素的位置,从而给新元素腾出位置来。如果该数组后面紧跟的是其它有用数据,那么为了防止覆盖有用数据,还不敢直接往后移动元素,必须得重新开辟一块内存,把所有的元素都复制过去。
  • 删除第 i 个元素就比较简单了,不管三七二十一,把第 i 个元素后面的所有元素都向前移动即可。

插入和删除数组元素都要移动内存,甚至重新开辟一块内存,这是相当消耗资源的。如果一个程序中有大量的此类操作,那么程序的性能将堪忧,这有悖于「C语言非常高效」的初衷,所以C语言并不支持动态数组。

数组越界

C语言数组是静态的,不能自动扩容,当下标小于零或大于等于数组长度时,就发生了越界(Out Of Bounds),访问到数组以外的内存。如果下标小于零,就会发生下限越界(Off Normal Lower);如果下标大于等于数组长度,就会发生上限越界(Off Normal Upper)。

C语言为了提高效率,保证操作的灵活性,并不会对越界行为进行检查,即使越界了,也能够正常编译,只有在运行期间才可能会发生问题。请看下面的代码:

#include <stdio.h>
int main()
{
    int a[3] = {10, 20, 30}, i;
    for(i=-2; i<=4; i++)
    {
        printf("a[%d]=%d\n", i, a[i]);
    }
    return 0;
}

运行结果:

a[-2]=33
a[-1]=0
a[0]=10
a[1]=20
a[2]=30
a[3]=3
a[4]=11146128

越界访问的数组元素的值都是不确定的,没有实际的含义,因为数组之外的内存我们并不知道是什么,可能是其它变量的值,可能是函数参数,可能是一个地址,这些都是不可控的。

数组溢出

当赋予数组的元素个数超过数组长度时,就会发生溢出(Overflow)。如下所示:

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

数组长度为3,初始化时却赋予5个元素,超出了数组容量,所以只能保存前3个元素,后面的元素被丢弃。

GCC、LLVM/Clang、低版本的 VS(例如 VS2010)发现数组溢出只会给出警告,并不会报错。但是高版本的 VS(例如 VS2015、VS2017)发现数组溢出时会报错,禁止编译通过。

变长数组

目前经常使用的C语言有三个版本,分别是 C89、C99 和 C11。C89(也称 ANSI C)是较早的版本,也是最经典的版本,国内大学几乎都是以该版本为基础进行授课。C99 和 C11 是后来对 C89 的升级,增添了一些新内容(不多),语法更加灵活了,同时兼容 C89。

各种编译器都能很好地支持 C89 标准,但对 C99 的支持却不同:开源组织的 GCC 和 Xcode 使用的 LLVM/Clang 已经支持了大部分(几乎全部)的 C99 标准,而微软的 VC、VS 对 C99 却不感兴趣,直到后来的 VS2013、VS2015、VS2017 才慢慢支持,而且支持得还不好。

为什么要讨论这个问题呢?因为 C89 和 C99 对数组做出了不同的规定:

  • 在 C89 中,必须使用常量表达式指明数组长度;也就是说,数组长度中不能包含变量,不管该变量有没有初始化。
  • 而在 C99 中,可以使用变量指明数组长度。

下面的代码使用常量表达式指明数组长度,在任何编译器下都能编译通过:

int a[10];  //长度为10
int b[3*5];  //长度为15
int c[4+8];  //长度为12

下面的代码使用变量指明数组长度,在 GCC 和 Xcode 下能够编译通过,而在 VC 和 VS(包括 VC 6.0、VS2010、VS2013、VS2015、VS2017 等)下都会报错:

int m = 10, n;
scanf("%d", &n);
int a[m], b[n];

在实际编程中,有时数组的长度不能提前确定,如果这个变化范围小,那么使用常量表达式定义一个足够大的数组就可以,如果这个变化范围很大,就可能会浪费内存,这时就可以使用变长数组。请看下面的代码:

#include <stdio.h>
int main()
{
    int n;
    printf("Input string length: ");
    scanf("%d", &n);
    scanf("%*[^\n]"); scanf("%*c");  //清空输入缓冲区
    char str[n];
    printf("Input a string: ");
    gets(str);
    puts(str);
    return 0;
}

在 GCC 和 Xcode 下的运行结果:

Input string length: 100↙
Input a string: http://c.biancheng.net/cpp/u/jiaocheng/↙
http://c.biancheng.net/cpp/u/jiaocheng/

变量的值在编译期间并不能确定,只有等到程序运行后,根据计算结果才能知道它的值到底是什么,所以数组长度中一旦包含了变量,那么数组长度在编译期间就不能确定了,也就不能为数组分配内存了,只有等到程序运行后,得到了变量的值,确定了具体的长度,才能给数组分配内存,我们将这样的数组称为变长数组(VLA, Variable Length Array)。

普通数组(固定长度的数组)是在编译期间分配内存的,而变长数组是在运行期间分配内存的。

变长数组仍然是静态数组

注意,变长数组是说数组的长度在定义之前可以改变,一旦定义了,就不能再改变了,所以变长数组的容量也是不能扩大或缩小的,它仍然是静态数组。以上面的代码为例,第 8 行代码是数组定义,此时就确定了数组的长度,在此之前长度可以随意改变,在此之后长度就固定了。

数组不是指针

通过前面的讲解,相信很多读者都会认为数组和指针是等价的,数组名表示数组的首地址。不幸的是,这是一种非常危险的想法,并不完全正确,前面我们将数组和指针等价起来是为了方便大家理解(在大多数情况下数组名确实可以当做指针使用),不至于被指针难倒,这节请大家放弃这种观念,我将会颠覆你的认知。

数组和指针不等价的一个典型案例就是求数组的长度,这个时候只能使用数组名,不能使用数组指针,前面我们已经强调过了,这里不妨再来演示一下:

#include <stdio.h>

int main(){
    int a[6] = {0, 1, 2, 3, 4, 5};
    int *p = a;
    int len_a = sizeof(a) / sizeof(int);
    int len_p = sizeof(p) / sizeof(int);
    printf("len_a = %d, len_p = %d\n", len_a, len_p);
    return 0;
}

运行结果:

len_a = 6, len_p = 1

数组是一系列数据的集合,没有开始和结束标志,p 仅仅是一个指向 int 类型的指针,编译器不知道它指向的是一个整数还是一堆整数,对 p 使用 sizeof 求得的是指针变量本身的长度。也就是说,编译器并没有把 p 和数组关联起来,p 仅仅是一个指针变量,不管它指向哪里,sizeof 求得的永远是它本身所占用的字节数。

站在编译器的角度讲,变量名、数组名都是一种符号,它们最终都要和数据绑定起来。变量名用来指代一份数据,数组名用来指代一组数据(数据集合),它们都是有类型的,以便推断出所指代的数据的长度。

数组也有类型,这是很多读者没有意识到的,大部分C语言书籍对这一点也含糊其辞!我们可以将 int、float、char 等理解为基本类型,将数组理解为由基本类型派生得到的稍微复杂一些的类型。sizeof 就是根据符号的类型来计算长度的。

对于数组 a,它的类型是int [6],表示这是一个拥有 6 个 int 数据的集合,1 个 int 的长度为 4,6 个 int 的长度为 4×6 = 24,sizeof 很容易求得。

对于指针变量 p,它的类型是int *,在 32 位环境下长度为 4,在 64 位环境下长度为 8。

归根结底,a 和 p 这两个符号的类型不同,指代的数据也不同,它们不是一码事,sizeof 是根据符号类型来求长度的,a 和 p 的类型不同,求得的长度自然也不一样。

参考链接

  1. http://c.biancheng.net/c/61/
  2. 《C和指针》()
©️2020 CSDN 皮肤主题: 书香水墨 设计师:CSDN官方博客 返回首页