所谓的数组越界，简单地讲就是指数组下标变量的取值超过了初始定义时的大小，导致对数组元素的访问出现在数组的范围之外，这类错误也是 C 语言程序中最常见的错误之一。

在 C 语言中，数组必须是静态的。换而言之，数组的大小必须在程序运行前就确定下来。由于 C 语言并不具有类似 Java 等语言中现有的静态分析工具的功能，可以对程序中数组下标取值范围进行严格检查，一旦发现数组上溢或下溢，都会因抛出异常而终止程序。也就是说，C 语言并不检验数组边界，数组的两端都有可能越界，从而使其他变量的数据甚至程序代码被破坏。

因此，数组下标的取值范围只能预先推断一个值来确定数组的维数，而检验数组的边界是程序员的职责。

一般情况下，数组的越界错误主要包括两种：数组下标取值越界与指向数组的指针的指向范围越界。

数组下标取值越界

数组下标取值越界主要是指访问数组的时候，下标的取值不在已定义好的数组的取值范围内，而访问的是无法获取的内存地址。例如，对于数组 int a[3]，它的下标取值范围是[0，2]（即a[0]、a[1] 与 a[2]）。如果我们的取值不在这个范围内（如 a[3]），就会发生越界错误。示例代码如下所示：

1int a[3];
2int i=0;
3for(i=0;i<4;i++)
3 m" i3 w. U* T 4{
5    a = i;
* f5 b0 k: F0 t! \5 Y* q 6}
7for(i=0;i<4;i++)
2 T$ b/ `; a; N1 R' S 8{
9 s3 C  P6 q" C/ U 9    printf("a[%d]=%d\n",i,a);
10}
9 l0 A( H% F$ a/ i% S9 ^* v

很显然，在上面的示例程序中，访问 a[3] 是非法的，将会发生越界错误。因此，我们应该将上面的代码修改成如下形式：

1int a[3];
2int i=0;
, _: C: u# k8 e% `3 F 3for(i=0;i<3;i++)
4{
5    a = i;
6}
7for(i=0;i<3;i++)
8{
9    printf("a[%d]=%d\n",i,a);
& V% A3 Y0 t6 u# p' ]10}
指向数组的指针的指向范围越界

指向数组的指针的指向范围越界是指定义数组时会返回一个指向第一个变量的头指针，对这个指针进行加减运算可以向前或向后移动这个指针，进而访问数组中所有的变量。但在移动指针时，如果不注意移动的次数和位置，会使指针指向数组以外的位置，导致数组发生越界错误。下面的示例代码就是移动指针时没有考虑到移动的次数和数组的范围，从而使程序访问了数组以外的存储单元。

1int i;
4 ~9 ^. R3 [7 G  T4 _1 R* P$ e 2int *p;
8 e# D, o5 W) ~( h 3int a[5];
" @! N) T: U& \ 4/*数组a的头指针赋值给指针p*/
5p=a;
6for(i=0;i<10;i++)
# L. V" ?  S6 C" N8 ` 7{
# J6 e% x; @# [8 p 8    /*指针p指向的变量*/
8 n( N# c7 z- a* a' P" s 9    *p=i+10;
4 n7 D; [( a( f4 ~& w# `10    /*指针p下一个变量*/
: J, z# v: H1 N) {! B9 \& _4 K11    p++;
/ a8 ^6 G; b: @0 |" ^! T2 H12}

在上面的示例代码中，for 循环会使指针 p 向后移动 10 次，并且每次向指针指向的单元赋值。但是，这里数组 a 的下标取值范围是 [0，4]（即 a[0]、a[1]、a[2]、a[3] 与 a[4]）。因此，后 5 次的操作会对未知的内存区域赋值，而这种向内存未知区域赋值的操作会使系统发生错误。正确的操作应该是指针移动的次数与数组中的变量个数相同，如下面的代码所示：

1int i;
2int *p;
  A# G8 K7 Z# @5 O: r) b& D 3int a[5];
$ G; @2 c0 C4 U* z5 ? 4/*数组a的头指针赋值给指针p*/
5p=a;
! n3 h# H/ [1 A  U3 Q% d 6for(i=0;i<5;i++)
7{
8    /*指针p指向的变量*/
9    *p=i+10;
$ r" e- a, _5 q& @* w: l  C! F10    /*指针p下一个变量*/
- R+ O" s' B; k9 y. r. U. t11    p++;
8 D6 }3 H4 ]1 \12}

为了加深大家对数组越界的了解，下面通过一段完整的数组越界示例来演示编程中数组越界将会导致哪些问题。

1#define PASSWORD "123456"
2int Test(char *str)
+ l  Z" n1 F$ U- Q" K" T/ } 3{
4    int flag;
5    char buffer[7];
6    flag=strcmp(str,PASSWORD);
7    strcpy(buffer,str);
8    return flag;
9}
10int main(void)
: w+ _9 Y& a/ c9 T8 j0 S11{
; o$ w# x5 L( O12    int flag=0;
; @5 s' ?6 z" ~* Z* [13    char str[1024];
14    while(1)
2 d, [8 C2 d0 h6 @4 O# Z6 B15    {
1 j+ ?6 G$ `" r% p9 v16        printf("请输入密码：  ");
17        scanf（"%s",str);
18        flag = Test(str);
19        if(flag)
20        {
3 c# N9 j$ N+ F, N8 _+ x: D% j21            printf("密码错误！\n");
22        }
% n8 p9 c/ W9 v5 U6 O2 |23            else
1 V; H0 q( Q( o  i! s; L. f+ @24            {
" J" {& q! Q+ L- h" d6 E25                printf("密码正确！\n");
26            }
; O1 d! X2 W7 w) S+ U  v27    }
28    return 0;
29}

上面的示例代码模拟了一个密码验证的例子，它将用户输入的密码与宏定义中的密码123456进行比较。很显然，本示例中最大的设计漏洞就在于 Test() 函数中的strcpy(buffer,str) 调用。

由于程序将用户输入的字符串原封不动地复制到 Test() 函数的数组 char buffer[7] 中。因此，当用户的输入大于 7 个字符的缓冲区尺寸时，就会发生数组越界错误，这也就是大家所谓的缓冲区溢出Buffer overflow 漏洞。

但是要注意，如果这个时候我们根据缓冲区溢出发生的具体情况填充缓冲区，不但可以避免程序崩溃，还会影响到程序的执行流程，甚至会让程序去执行缓冲区里的代码。示例运行结果为：

1请输入密码:12345
2密码错误！
3请输入密码:123456
# R1 Y' ]7 l, W 4密码正确！
5请输入密码:1234567
" @* [2 A7 Z3 Y; q( y. E) c* G9 b 6密码正确！
9 `* h( J* ]8 S! {: n5 a& G7 Z 7请输入密码:aaaaaaa
  i3 C( K8 r" p8 H; r 8密码正确！
9请输入密码:0123456
; R6 Q' `' V- h2 y10密码错误！
; c. d8 P6 _' G& G' P" N11请输入密码:
4 K# r+ q" l/ z" i

在示例代码中，flag 变量实际上是一个标志变量，其值将决定着程序是进入密码错误的流程（非 0）还是“密码正确”的流程（0）。当我们输入错误的字符串1234567或者aaaaaaa，程序也都会输出“密码正确”。但在输入0123456的时候，程序却输出“密码错误”，这究竟是为什么呢？

其实，原因很简单。当调用 Test() 函数时，系统将会给它分配一片连续的内存空间，而变量 char buffer[7] 与 int flag 将会紧挨着进行存储，用户输入的字符串将会被复制进 buffer[7] 中。如果这个时候，我们输入的字符串数量超过 6 个（注意，有字符串截断符也算一个），那么超出的部分将破坏掉与它紧邻着的 flag 变量的内容。

当输入的密码不是宏定义的123456时，字符串比较将返回 1 或 -1。我们都知道，内存中的数据按照 4 字节（DWORD）逆序存储，所以当 flag 为 1 时，在内存中存储的是0x01000000。如果我们输入包含 7 个字符的错误密码，如aaaaaaa，那么字符串截断符 0x00 将写入 flag 变量，这样溢出数组的一个字节 0x00 将恰好把逆序存放的 flag 变量改为 0x00000000。在函数返回后，一旦 main 函数的 flag 为 0，就会输出“密码正确”。这样，我们就用错误的密码得到了正确密码的运行效果。

而对于0123456，因为在进行字符串的大小比较时，它小于123456，flag的值是 -1，在内存中将按照补码存放负数，所以实际存储的不是 0x01000000 而是0xffffffff。那么字符串截断后符 0x00 淹没后，变成 0x00ffffff，还是非 0，所以没有进入正确分支。

其实，本示例只是用一个字节淹没了邻接变量，导致程序进入密码正确的处理流程，使设计的验证功能失效。

尽量显式地指定数组的边界

在 C 语言中，为了提高运行效率，给程序员更大的空间，为指针操作带来更多的方便，C 语言内部本身不检查数组下标表达式的取值是否在合法范围内，也不检查指向数组元素的指针是不是移出了数组的合法区域。因此，在编程中使用数组时就必须格外谨慎，在对数组进行读写操作时都应当进行相应的检查，以免对数组的操作超过数组的边界，从而发生缓冲区溢出漏洞。

要避免程序因数组越界所发生的错误，首先就需要从数组的边界定义开始。尽量显式地指定数组的边界，即使它已经由初始化值列表隐式指定。示例代码如下所示：

1int a[]={1,2,3,4,5,6,7,8,9,10};
. k7 i( q& g" [

很显然，对于上面的数组 a[]，虽然编译器可以根据始化值列表来计算出数组的长度。但是，如果我们显式地指定该数组的长度，例如：

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

它不仅使程序具有更好的可读性，并且大多数编译器在数组长度小于初始化值列表的长度时还会发生相应警告。

当然，也可以使用宏的形式来显式指定数组的边界（实际上，这也是最常用的指定方法），如下面的代码所示：

1#define MAX 10
0 y2 o  k6 b# W, C' Q  H% C: q6 J2…
* P0 B0 b) o( S. g3int a[MAX]={1,2,3,4,5,6,7,8,9,10};

除此之外，在 C99 标准中，还允许我们使用单个指示符为数组的两段“分配”空间，如下面的代码所示：

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

在上面的 a[MAX]数组中，如果 MAX 大于 10，数组中间将用 0 值元素进行填充（填充的个数为 MAX-10，并从 a[5] 开始进行 0 值填充）；如果 MAX 小于 10，[MAX-5]之前的 5 个元素（1，2，3，4，5）中将有几个被[MAX-5]之后的 5 个元素（6，7，8，9，10）所覆盖，示例代码如下所示：

1#define MAX 10
: \/ _9 @' D: B' n) x' \ 2#define MAX1 15
3#define MAX2 6
& [2 s3 r' I; e7 R/ [ 4int main(void)
5{
6    int a[MAX]={1,2,3,4,5,[MAX-5]=6,7,8,9,10};
7    int b[MAX1]={1,2,3,4,5,[MAX1-5]=6,7,8,9,10};
2 p: ?4 D: c: P6 y2 q 8    int c[MAX2]={1,2,3,4,5,[MAX2-5]=6,7,8,9,10};
, i+ ~3 ?7 y  l* W 9    int i=0;
3 z# ~& x& }) a3 D0 |* z9 h10    int j=0;
11    int z=0;
12    printf("a[MAX]：\n");
13    for(i=0;i<MAX;i++)
14    {
; y: x% `) `5 Y15        printf("a[%d]=%d ",i,a);
16    }
17    printf("\nb[MAX1]：\n");
& S. w% m/ S; q9 d18    for(j=0;j<MAX1;j++)
19    {
20        printf("b[%d]=%d ",j,b[j]);
21    }
22    printf("\nc[MAX2]：\n");
23    for(z=0;z<MAX2;z++)
5 ?% }: B0 O9 \# M2 g1 O6 P; S& H( i24    {
25        printf("c[%d]=%d ",z,c[z]);
26    }
; q7 x, G' q7 M8 |+ R0 |1 o27    printf("\n");
28    return 0;
5 @4 ^& W/ g8 [2 v9 Z; v29}
2 U; |' f6 F3 k8 ~

运行结果为：

1a[MAX]：
& }+ l* E/ w7 d# @! Z2a[0]=1 a[1]=2 a[2]=3 a[3]=4 a[4]=5 a[5]=6 a[6]=7 a[7]=8 a[8]=9 a[9]=10
3b[MAX1]：
  Y, K: v" ~6 H4 s4b[0]=1 b[1]=2 b[2]=3 b[3]=4 b[4]=5 b[5]=0 b[6]=0 b[7]=0 b[8]=0 b[9]=0 b[10]=6 b[11]=7 b[12]=8 b[13]=9 b[14]=10
5c[MAX2]：
6c[0]=1 c[1]=6 c[2]=7 c[3]=8 c[4]=9 c[5]=10
对数组做越界检查，确保索引值位于合法的范围之内

要避免数组越界，除了上面所阐述的显式指定数组的边界之外，还可以在数组使用之前进行越界检查，检查数组的界限和字符串（也以数组的方式存放）的结束，以保证数组索引值位于合法的范围之内。例如，在写处理数组的函数时，一般应该有一个范围参数；在处理字符串时总检查是否遇到空字符‘\0’。

来看下面一段代码示例：

1#define ARRAY_NUM 10
2int *TestArray(int num,int value)
3{
& w' }. _; r1 L4 z 4    int *arr=NULL;
5    arr=(int *)malloc(sizeof(int)*ARRAY_NUM);
6    if(arr!=NULL)
* E* _5 d8 \5 D4 U* g2 Q 7    {
9 J3 N3 J6 e8 W  I, E6 c* {" @ 8        arr[num]=value;
' n1 i/ ~' t4 b# F  c 9    }
10    else
11    {
8 H7 Q0 b; h  g! W& O) H/ f: P12        /*处理arr==NULL*/
13    }
( Y3 Q# v0 C8 f/ n5 b- V14    return arr;
15}
  v2 k/ q  \- {) h

从上面的int*TestArray（int num，int value）函数中不难看出，其中存在着一个很明显的问题，那就是无法保证 num 参数是否越界（即当num>=ARRAY_NUM的情况）。因此，应该对 num 参数进行越界检查，示例代码如下所示：

1int *TestArray(int num,int value)
2{
3    int *arr=NULL;
4    /*越界检查(越上界)*/
5    if(num<ARRAY_NUM)
6    {
& [4 T# A! _* ]- Y 7        arr=(int *)malloc(sizeof(int)*ARRAY_NUM);
8        if(arr!=NULL)
* c( `- L; u2 j0 V2 o* r 9        {
2 A4 P+ \8 C( J( i10            arr[num]=value;
11        }
12        else
& J0 o% p1 }6 }13        {
$ N. w  s, H; y14            /*处理arr==NULL*/
15        }
8 Q% q4 c, |8 N0 S* R16    }
" P" g" ^7 M7 E2 L  |% B7 F17    return arr;
18}

这样通过if（num<ARRAY_NUM）语句进行越界检查，从而保证 num 参数没有越过这个数组的上界。现在看起来，TestArray() 函数应该没什么问题，也不会发生什么越界错误。

但是，如果仔细检查，TestArray() 函数仍然还存在一个致命的问题，那就是没有检查数组的下界。由于这里的 num 参数类型是 int 类型，因此可能为负数。如果 num 参数所传递的值为负数，将导致在 arr 所引用的内存边界之外进行写入。

当然，你可以通过向if（num<ARRAY_NUM）语句里面再加一个条件进行测试，如下面的代码所示：

1if(num>=0&&num<ARRAY_NUM)
0 F" j" u& v9 V  q* u, W2{
3}
6 _1 t* `  H5 p8 @

但是，这样的函数形式对调用者来说是不友好的（由于 int 类型的原因，对调用者来说仍然可以传递负数，至于在函数中怎么处理那是另外一件事情），因此，最佳的解决方案是将 num 参数声明为 size_t 类型，从根本上防止它传递负数，示例代码如下所示：

1int *TestArray(size_t num,int value)
2{
3    int *arr=NULL;
4 C: Z/ x& X  k# B. @3 H. G 4    /*越界检查(越上界)*/
5    if(num<ARRAY_NUM)
6    {
7        arr=(int *)malloc(sizeof(int)*ARRAY_NUM);
8        if(arr!=NULL)
) `8 n6 a1 n1 B, E5 P% I9 O 9        {
- G' S  @* D7 m* m. K10            arr[num]=value;
11        }
. u) z, d% Z: N. q7 J, K12        else
13        {
1 A" `4 u" f8 A) t1 ^14            /*处理arr==NULL*/
& q) [' {9 N! e' n0 C2 H15        }
0 x# m2 ^0 ~- V9 @% |16    }
17    return arr;
18}
( d* @% O. B. K: ?$ q9 N$ c, `获取数组的长度时不要对指针应用 sizeof 操作符

在 C 语言中，sizeof 这个其貌不扬的家伙经常会让无数程序员叫苦连连。同时，它也是各大公司争相选用的面试必备题目。简单地讲，sizeof 是一个单目操作符，不是函数。其作用就是返回一个操作数所占的内存字节数。其中，操作数可以是一个表达式或括在括号内的类型名，操作数的存储大小由操作数的类型来决定。例如，对于数组 int a[5]，可以使用sizeof(a)来获取数组的长度，使用sizeof(a[0])来获取数组元素的长度。

但需要注意的是，sizeof 操作符不能用于函数类型、不完全类型（指具有未知存储大小的数据类型，如未知存储大小的数组类型、未知内容的结构或联合类型、void 类型等）与位字段。例如，以下都是不正确形式：

1/*若此时max定义为intmax()；*/
0 q( k+ t0 ~. e( p  r/ K 2sizeof(max)
" B4 \, z4 n/ @6 ^4 Y  G/ s! R1 l 3/*若此时arr定义为char arr[MAX]，且MAX未知*/
4sizeof(arr)
5/*不能够用于void类型*/
6sizeof(void)
: O6 n( \4 k) y% E 7/*不能够用于位字段*/
/ _9 j5 v4 A  e 8struct S
9{
10    unsigned int f1 : 1;
, f5 N) C5 ^, Z, Q- j! Y9 T3 d11    unsigned int f2 : 5;
6 K7 X( n1 h: f# x) Q) E* J, r12    unsigned int f3 : 12;
13};
14sizeof(S.f1);

了解 sizeof 操作符之后，现在来看下面的示例代码：

1void Init(int arr[])
2{
4 H5 ]! y1 L3 d5 A1 E4 A' @ 3    size_t i=0;
9 r( b, V+ P8 w# ^. S1 G7 e, X 4    for(i=0;i<sizeof(arr)/sizeof(arr[0]);i++)
5    {
% W# Q3 `: H! L0 h- C 6        arr=i;
2 w+ H8 g+ V. z5 @ 7    }
8}
9int main(void)
2 H: D# \/ X* g0 ?0 R10{
5 ?9 G! J3 }- G- O2 }/ h9 @11    int i=0;
12    int a[10];
$ u( J0 x8 t; D  b% q+ O# h& G13    Init(a);
14    for(i=0;i<10;i++)
# P* G3 R. X) d4 s15    {
8 _1 \2 s6 H+ \16        printf("%d\n",a);
! f% X8 q0 A! S# i9 F17    }
. j* M* w& y/ r6 v4 \: ~- M18    return 0;
- a/ _: i6 S3 F8 U7 l: y19}

从表面看，上面代码的输出结果应该是0，1，2，3，4，5，6，7，8，9，但实际结果却出乎我们的意料，如图 1 所示。

图 1 示例代码在 VC++2010 中的运行结果

是什么原因导致这个结果呢？

很显然，上面的示例代码在void Init(int arr[])函数中接收了一个int arr[]类型的形参，并且在main函数中向它传递一个a[10]实参。同时，在 Init() 函数中通过sizeof(arr)/sizeof(arr[0])来确定这个数组元素的数量和初始化值。

在这里出现了一个很大问题：由于 arr 参数是一个形参，它是一个指针类型，其结果是sizeof(arr)=sizeof(int*)。在 IA-32 中，sizeof(arr)/sizeof(arr[0])的结果为 1。因此，最后的结果如图 1 所示。

对于上面的示例代码，我们可以通过传入数组的长度的方式来解决这个问题，示例代码如下：

1void Init(int arr[],size_t arr_len)
2{
3    size_t i=0;
4    for(i=0;i<arr_len;i++)
5    {
6        arr=i;
7    }
8}
; j; p9 X+ Z. j. r 9int main(void)
( i! Q) ]7 o6 t. H  Y0 o10{
11    int i=0;
12    int a[10];
13    Init(a,10);
7 |2 Z3 i, D+ Z5 [) j- ?% O14    for(i=0;i<10;i++)
2 y( _1 y. o; I3 y6 q' q15    {
3 D5 X) N# ~" X/ m, ~3 G- i16        printf("%d\n",a);
" a: H' B( D+ T1 D; J% U5 r17    }
! A8 ^# e2 R& m: L1 v9 Y+ a6 @18    return 0;
. a3 H8 \7 n0 h; _$ t9 a2 Y19}

除此之外，我们还可以通过指针的方式来解决上面的问题，示例代码如下所示：

1void Init(int (*arr)[10])
# W8 S9 j; z& q- C8 V 2{
5 I8 B6 f) {% e) [* c 3    size_t i=0;
4 C: Y, L- E2 R8 B5 C  j* a# K 4    for(i=0;i< sizeof(*arr)/sizeof(int);i++)
5    {
7 p- T6 V; L8 M 6        (*arr)=i;
7    }
7 l! a4 `6 z1 h  Q! t/ A3 M/ {& d% C 8}
# D. K9 }5 P7 S" P# H 9int main(void)
10{
, v  Y: g3 ^, z: F. W) J11    int i=0;
% a& M  U( D: ?: r3 [+ k) L! w* l- ~12    int a[10];
0 }: e) C( A& g5 t  d13    Init(&a);
14    for(i=0;i<10;i++)
15    {
) ]& k+ `, @3 d1 C  @- X1 @2 Y16        printf("%d\n",a);
17    }
18    return 0;
19}

现在，Init() 函数中的 arr 参数是一个指向arr[10]类型的指针。需要特别注意的是，这里绝对不能够使用void Init(int(*arr)[])来声明函数，而是必须指明要传入的数组的大小，否则sizeof(*arr)无法计算。但是在这种情况下，再通过 sizeof 来计算数组大小已经没有意义了，因为此时数组大小已经指定为 10 了。