所謂的數(shù)組越界，簡單地講就是指數(shù)組下標(biāo)變量的取值超過了初始定義時的大小，導(dǎo)致對數(shù)組元素的訪問出現(xiàn)在數(shù)組的范圍之外，這類錯誤也是 C 語言程序中最常見的錯誤之一。

在 C 語言中，數(shù)組必須是靜態(tài)的。換而言之，數(shù)組的大小必須在程序運(yùn)行前就確定下來。由于 C 語言并不具有類似 Java 等語言中現(xiàn)有的靜態(tài)分析工具的功能，可以對程序中數(shù)組下標(biāo)取值范圍進(jìn)行嚴(yán)格檢查，一旦發(fā)現(xiàn)數(shù)組上溢或下溢，都會因拋出異常而終止程序。也就是說，C 語言并不檢驗(yàn)數(shù)組邊界，數(shù)組的兩端都有可能越界，從而使其他變量的數(shù)據(jù)甚至程序代碼被破壞。

因此，數(shù)組下標(biāo)的取值范圍只能預(yù)先推斷一個值來確定數(shù)組的維數(shù)，而檢驗(yàn)數(shù)組的邊界是程序員的職責(zé)。

一般情況下，數(shù)組的越界錯誤主要包括兩種：數(shù)組下標(biāo)取值越界與指向數(shù)組的指針的指向范圍越界。

數(shù)組下標(biāo)取值越界

數(shù)組下標(biāo)取值越界主要是指訪問數(shù)組的時候，下標(biāo)的取值不在已定義好的數(shù)組的取值范圍內(nèi)，而訪問的是無法獲取的內(nèi)存地址。例如，對于數(shù)組 int a[3]，它的下標(biāo)取值范圍是 [0，2]（即 a[0]、a[1] 與 a[2]）。如果我們的取值不在這個范圍內(nèi)（如 a[3]），就會發(fā)生越界錯誤。示例代碼如下所示：

int a[3];
int i=0;
for(i=0;i<4;i++)
{
  a[i] = i;
}
for(i=0;i<4;i++)
{
  printf("a[%d]=%d\n",i,a[i]);
}

很顯然，在上面的示例程序中，訪問 a[3] 是非法的，將會發(fā)生越界錯誤。因此，我們應(yīng)該將上面的代碼修改成如下形式：

int a[3];
int i=0;
for(i=0;i<3;i++)
{
  a[i] = i;
}
for(i=0;i<3;i++)
{
  printf("a[%d]=%d\n",i,a[i]);
}

指向數(shù)組的指針的指向范圍越界

指向數(shù)組的指針的指向范圍越界是指定義數(shù)組時會返回一個指向第一個變量的頭指針，對這個指針進(jìn)行加減運(yùn)算可以向前或向后移動這個指針，進(jìn)而訪問數(shù)組中所有的變量。但在移動指針時，如果不注意移動的次數(shù)和位置，會使指針指向數(shù)組以外的位置，導(dǎo)致數(shù)組發(fā)生越界錯誤。下面的示例代碼就是移動指針時沒有考慮到移動的次數(shù)和數(shù)組的范圍，從而使程序訪問了數(shù)組以外的存儲單元。

int i;
int *p;
int a[5];
/*數(shù)組a的頭指針賦值給指針p*/
p=a;
for(i=0;i<10;i++)
{
  /*指針p指向的變量*/
  *p=i+10;
  /*指針p下一個變量*/
  p++;
}

在上面的示例代碼中，for 循環(huán)會使指針 p 向后移動 10 次，并且每次向指針指向的單元賦值。但是，這里數(shù)組 a 的下標(biāo)取值范圍是 [0，4]（即 a[0]、a[1]、a[2]、a[3] 與 a[4]）。因此，后 5 次的操作會對未知的內(nèi)存區(qū)域賦值，而這種向內(nèi)存未知區(qū)域賦值的操作會使系統(tǒng)發(fā)生錯誤。正確的操作應(yīng)該是指針移動的次數(shù)與數(shù)組中的變量個數(shù)相同，如下面的代碼所示：

int i;
int *p;
int a[5];
/*數(shù)組a的頭指針賦值給指針p*/
p=a;
for(i=0;i<5;i++)
{
  /*指針p指向的變量*/
  *p=i+10;
  /*指針p下一個變量*/
  p++;
}

為了加深大家對數(shù)組越界的了解，下面通過一段完整的數(shù)組越界示例來演示編程中數(shù)組越界將會導(dǎo)致哪些問題。

#define PASSWORD "123456"
int Test(char *str)
{
  int flag;
  char buffer[7];
  flag=strcmp(str,PASSWORD);
  strcpy(buffer,str);
  return flag;
}
int main(void)
{
  int flag=0;
  char str[1024];
  while(1)
  {
    printf("請輸入密碼： ");
    scanf（"%s",str);
    flag = Test(str);
    if(flag)
    {
      printf("密碼錯誤！\n");
    }
      else
      {
        printf("密碼正確！\n");
      }
  }
  return 0;
}

上面的示例代碼模擬了一個密碼驗(yàn)證的例子，它將用戶輸入的密碼與宏定義中的密碼“123456”進(jìn)行比較。很顯然，本示例中最大的設(shè)計(jì)漏洞就在于 Test() 函數(shù)中的 strcpy(buffer,str) 調(diào)用。

由于程序?qū)⒂脩糨斎氲淖址獠粍拥貜?fù)制到 Test() 函數(shù)的數(shù)組 char buffer[7] 中。因此，當(dāng)用戶的輸入大于 7 個字符的緩沖區(qū)尺寸時，就會發(fā)生數(shù)組越界錯誤，這也就是大家所謂的緩沖區(qū)溢出(Buffer overflow)漏洞。但是要注意，如果這個時候我們根據(jù)緩沖區(qū)溢出發(fā)生的具體情況填充緩沖區(qū)，不但可以避免程序崩潰，還會影響到程序的執(zhí)行流程，甚至?xí)尦绦蛉?zhí)行緩沖區(qū)里的代碼。示例運(yùn)行結(jié)果為：

請輸入密碼:12345
密碼錯誤！
請輸入密碼:123456
密碼正確！
請輸入密碼:1234567
密碼正確！
請輸入密碼:aaaaaaa
密碼正確！
請輸入密碼:0123456
密碼錯誤！
請輸入密碼:

在示例代碼中，flag 變量實(shí)際上是一個標(biāo)志變量，其值將決定著程序是進(jìn)入“密碼錯誤”的流程（非 0）還是“密碼正確”的流程（0）。當(dāng)我們輸入錯誤的字符串“1234567”或者“aaaaaaa”，程序也都會輸出“密碼正確”。但在輸入“0123456”的時候，程序卻輸出“密碼錯誤”，這究竟是為什么呢？

其實(shí)，原因很簡單。當(dāng)調(diào)用 Test() 函數(shù)時，系統(tǒng)將會給它分配一片連續(xù)的內(nèi)存空間，而變量 char buffer[7] 與 int flag 將會緊挨著進(jìn)行存儲，用戶輸入的字符串將會被復(fù)制進(jìn) buffer[7] 中。如果這個時候，我們輸入的字符串?dāng)?shù)量超過 6 個（注意，有字符串截?cái)喾菜阋粋€），那么超出的部分將破壞掉與它緊鄰著的 flag 變量的內(nèi)容。

當(dāng)輸入的密碼不是宏定義的“123456”時，字符串比較將返回 1 或 -1。我們都知道，內(nèi)存中的數(shù)據(jù)按照 4 字節(jié)（DWORD）逆序存儲，所以當(dāng) flag 為 1 時，在內(nèi)存中存儲的是 0x01000000。如果我們輸入包含 7 個字符的錯誤密碼，如“aaaaaaa”，那么字符串截?cái)喾?0x00 將寫入 flag 變量，這樣溢出數(shù)組的一個字節(jié) 0x00 將恰好把逆序存放的 flag 變量改為 0x00000000。在函數(shù)返回后，一旦 main 函數(shù)的 flag 為 0，就會輸出“密碼正確”。這樣，我們就用錯誤的密碼得到了正確密碼的運(yùn)行效果。

而對于“0123456”，因?yàn)樵谶M(jìn)行字符串的大小比較時，它小于“123456”，flag的值是 -1，在內(nèi)存中將按照補(bǔ)碼存放負(fù)數(shù)，所以實(shí)際存儲的不是 0x01000000 而是 0xffffffff。那么字符串截?cái)嗪蠓?0x00 淹沒后，變成 0x00ffffff，還是非 0，所以沒有進(jìn)入正確分支。

其實(shí)，本示例只是用一個字節(jié)淹沒了鄰接變量，導(dǎo)致程序進(jìn)入密碼正確的處理流程，使設(shè)計(jì)的驗(yàn)證功能失效。

盡量顯式地指定數(shù)組的邊界

在 C 語言中，為了提高運(yùn)行效率，給程序員更大的空間，為指針操作帶來更多的方便，C 語言內(nèi)部本身不檢查數(shù)組下標(biāo)表達(dá)式的取值是否在合法范圍內(nèi)，也不檢查指向數(shù)組元素的指針是不是移出了數(shù)組的合法區(qū)域。因此，在編程中使用數(shù)組時就必須格外謹(jǐn)慎，在對數(shù)組進(jìn)行讀寫操作時都應(yīng)當(dāng)進(jìn)行相應(yīng)的檢查，以免對數(shù)組的操作超過數(shù)組的邊界，從而發(fā)生緩沖區(qū)溢出漏洞。

要避免程序因數(shù)組越界所發(fā)生的錯誤，首先就需要從數(shù)組的邊界定義開始。盡量顯式地指定數(shù)組的邊界，即使它已經(jīng)由初始化值列表隱式指定。示例代碼如下所示：

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

很顯然，對于上面的數(shù)組 a[]，雖然編譯器可以根據(jù)始化值列表來計(jì)算出數(shù)組的長度。但是，如果我們顯式地指定該數(shù)組的長度，例如：

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

它不僅使程序具有更好的可讀性，并且大多數(shù)編譯器在數(shù)組長度小于初始化值列表的長度時還會發(fā)生相應(yīng)警告。

當(dāng)然，也可以使用宏的形式來顯式指定數(shù)組的邊界（實(shí)際上，這也是最常用的指定方法），如下面的代碼所示：

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

除此之外，在 C99 標(biāo)準(zhǔn)中，還允許我們使用單個指示符為數(shù)組的兩段“分配”空間，如下面的代碼所示：

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

在上面的 a[MAX] 數(shù)組中，如果 MAX 大于 10，數(shù)組中間將用 0 值元素進(jìn)行填充（填充的個數(shù)為 MAX-10，并從 a[5] 開始進(jìn)行 0 值填充）；如果 MAX 小于 10，“[MAX-5]”之前的 5 個元素（1，2，3，4，5）中將有幾個被“[MAX-5]”之后的 5 個元素（6，7，8，9，10）所覆蓋，示例代碼如下所示：

#define MAX 10
#define MAX1 15
#define MAX2 6
int main(void)
{
  int a[MAX]={1,2,3,4,5,[MAX-5]=6,7,8,9,10};
  int b[MAX1]={1,2,3,4,5,[MAX1-5]=6,7,8,9,10};
  int c[MAX2]={1,2,3,4,5,[MAX2-5]=6,7,8,9,10};
  int i=0;
  int j=0;
  int z=0;
  printf("a[MAX]：\n");
  for(i=0;i<MAX;i++)
  {
    printf("a[%d]=%d ",i,a[i]);
  }
  printf("\nb[MAX1]：\n");
  for(j=0;j<MAX1;j++)
  {
    printf("b[%d]=%d ",j,b[j]);
  }
  printf("\nc[MAX2]：\n");
  for(z=0;z<MAX2;z++)
  {
    printf("c[%d]=%d ",z,c[z]);
  }
  printf("\n");
  return 0;
}

運(yùn)行結(jié)果為：

a[MAX]：
a[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
b[MAX1]：
b[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
c[MAX2]：
c[0]=1 c[1]=6 c[2]=7 c[3]=8 c[4]=9 c[5]=10

對數(shù)組做越界檢查，確保索引值位于合法的范圍之內(nèi)

要避免數(shù)組越界，除了上面所闡述的顯式指定數(shù)組的邊界之外，還可以在數(shù)組使用之前進(jìn)行越界檢查，檢查數(shù)組的界限和字符串（也以數(shù)組的方式存放）的結(jié)束，以保證數(shù)組索引值位于合法的范圍之內(nèi)。例如，在寫處理數(shù)組的函數(shù)時，一般應(yīng)該有一個范圍參數(shù)；在處理字符串時總檢查是否遇到空字符‘\0'。

來看下面一段代碼示例：

#define ARRAY_NUM 10
int *TestArray(int num,int value)
{
  int *arr=NULL;
  arr=(int *)malloc(sizeof(int)*ARRAY_NUM);
  if(arr!=NULL)
  {
    arr[num]=value;
  }
  else
  {
    /*處理arr==NULL*/
  }
  return arr;
}

從上面的“int*TestArray（int num，int value）”函數(shù)中不難看出，其中存在著一個很明顯的問題，那就是無法保證 num 參數(shù)是否越界（即當(dāng) num>=ARRAY_NUM 的情況）。因此，應(yīng)該對 num 參數(shù)進(jìn)行越界檢查，示例代碼如下所示：

int *TestArray(int num,int value)
{
  int *arr=NULL;
  /*越界檢查(越上界)*/
  if(num<ARRAY_NUM)
  {
    arr=(int *)malloc(sizeof(int)*ARRAY_NUM);
    if(arr!=NULL)
    {
      arr[num]=value;
    }
    else
    {
      /*處理arr==NULL*/
    }
  }
  return arr;
}

這樣通過“if（num<ARRAY_NUM）”語句進(jìn)行越界檢查，從而保證 num 參數(shù)沒有越過這個數(shù)組的上界?，F(xiàn)在看起來，TestArray() 函數(shù)應(yīng)該沒什么問題，也不會發(fā)生什么越界錯誤。

但是，如果仔細(xì)檢查，TestArray() 函數(shù)仍然還存在一個致命的問題，那就是沒有檢查數(shù)組的下界。由于這里的 num 參數(shù)類型是 int 類型，因此可能為負(fù)數(shù)。如果 num 參數(shù)所傳遞的值為負(fù)數(shù)，將導(dǎo)致在 arr 所引用的內(nèi)存邊界之外進(jìn)行寫入。

當(dāng)然，你可以通過向“if（num<ARRAY_NUM）”語句里面再加一個條件進(jìn)行測試，如下面的代碼所示：

 if(num>=0&&num<ARRAY_NUM)
 {
 }

但是，這樣的函數(shù)形式對調(diào)用者來說是不友好的（由于 int 類型的原因，對調(diào)用者來說仍然可以傳遞負(fù)數(shù)，至于在函數(shù)中怎么處理那是另外一件事情），因此，最佳的解決方案是將 num 參數(shù)聲明為 size_t 類型，從根本上防止它傳遞負(fù)數(shù)，示例代碼如下所示：

int *TestArray(size_t num,int value)
{
  int *arr=NULL;
  /*越界檢查(越上界)*/
  if(num<ARRAY_NUM)
  {
    arr=(int *)malloc(sizeof(int)*ARRAY_NUM);
    if(arr!=NULL)
    {
      arr[num]=value;
    }
    else
    {
      /*處理arr==NULL*/
    }
  }
  return arr;
}

獲取數(shù)組的長度時不要對指針應(yīng)用 sizeof 操作符

在 C 語言中，sizeof 這個其貌不揚(yáng)的家伙經(jīng)常會讓無數(shù)程序員叫苦連連。同時，它也是各大公司爭相選用的面試必備題目。簡單地講，sizeof 是一個單目操作符，不是函數(shù)。其作用就是返回一個操作數(shù)所占的內(nèi)存字節(jié)數(shù)。其中，操作數(shù)可以是一個表達(dá)式或括在括號內(nèi)的類型名，操作數(shù)的存儲大小由操作數(shù)的類型來決定。例如，對于數(shù)組 int a[5]，可以使用“sizeof(a)”來獲取數(shù)組的長度，使用“sizeof(a[0])”來獲取數(shù)組元素的長度。

但需要注意的是，sizeof 操作符不能用于函數(shù)類型、不完全類型（指具有未知存儲大小的數(shù)據(jù)類型，如未知存儲大小的數(shù)組類型、未知內(nèi)容的結(jié)構(gòu)或聯(lián)合類型、void 類型等）與位字段。例如，以下都是不正確形式：

/*若此時max定義為intmax()；*/
sizeof(max)
/*若此時arr定義為char arr[MAX]，且MAX未知*/
sizeof(arr)
/*不能夠用于void類型*/
sizeof(void)
/*不能夠用于位字段*/
struct S
{
  unsigned int f1 : 1;
  unsigned int f2 : 5;
  unsigned int f3 : 12;
};
sizeof(S.f1);

了解 sizeof 操作符之后，現(xiàn)在來看下面的示例代碼：

void Init(int arr[])
{
  size_t i=0;
  for(i=0;i<sizeof(arr)/sizeof(arr[0]);i++)
  {
    arr[i]=i;
  }
}
int main(void)
{
  int i=0;
  int a[10];
  Init(a);
  for(i=0;i<10;i++)
  {
    printf("%d\n",a[i]);
  }
  return 0;
}

從表面看，上面代碼的輸出結(jié)果應(yīng)該是“0，1，2，3，4，5，6，7，8，9”，但實(shí)際結(jié)果卻出乎我們的意料，如圖 1 所示。

是什么原因?qū)е逻@個結(jié)果呢？

很顯然，上面的示例代碼在“void Init(int arr[])”函數(shù)中接收了一個“int arr[]”類型的形參，并且在main函數(shù)中向它傳遞一個“a[10]”實(shí)參。同時，在 Init() 函數(shù)中通過“sizeof(arr)/sizeof(arr[0])”來確定這個數(shù)組元素的數(shù)量和初始化值。

在這里出現(xiàn)了一個很大問題：由于 arr 參數(shù)是一個形參，它是一個指針類型，其結(jié)果是“sizeof(arr)=sizeof(int*)”。在 IA-32 中，“sizeof(arr)/sizeof(arr[0])”的結(jié)果為 1。因此，最后的結(jié)果如圖 1 所示。

對于上面的示例代碼，我們可以通過傳入數(shù)組的長度的方式來解決這個問題，示例代碼如下：

void Init(int arr[],size_t arr_len)
{
  size_t i=0;
  for(i=0;i<arr_len;i++)
  {
    arr[i]=i;
  }
}
int main(void)
{
  int i=0;
  int a[10];
  Init(a,10);
  for(i=0;i<10;i++)
  {
    printf("%d\n",a[i]);
  }
  return 0;
}

除此之外，我們還可以通過指針的方式來解決上面的問題，示例代碼如下所示：

void Init(int (*arr)[10])
{
  size_t i=0;
  for(i=0;i< sizeof(*arr)/sizeof(int);i++)
  {
    (*arr)[i]=i;
  }
}
int main(void)
{
  int i=0;
  int a[10];
  Init(&a);
  for(i=0;i<10;i++)
  {
    printf("%d\n",a[i]);
  }
  return 0;
}

現(xiàn)在，Init() 函數(shù)中的 arr 參數(shù)是一個指向“arr[10]”類型的指針。需要特別注意的是，這里絕對不能夠使用“void Init(int(*arr)[])”來聲明函數(shù)，而是必須指明要傳入的數(shù)組的大小，否則“sizeof(*arr)”無法計(jì)算。但是在這種情況下，再通過 sizeof 來計(jì)算數(shù)組大小已經(jīng)沒有意義了，因?yàn)榇藭r數(shù)組大小已經(jīng)指定為 10 了。

以上就是C/C++ 避免數(shù)組越界的方法的詳細(xì)內(nèi)容，更多關(guān)于C/C++ 避免數(shù)組越界的資料請關(guān)注腳本之家其它相關(guān)文章！

最新評論