精华内容
下载资源
问答
  • 数组越界
    千次阅读
    2021-02-22 22:10:29

    平时打题的时候,有时找一个bug找半天,就很难顶。

    刚学数组那会儿,经常会看到数组越界四个字,当时我也是一脸懵逼 ,现在终于有时间来抓一下这条虫了。

    定义:所谓数组越界,就是指数组下标变量的取值超过了初始定义时的大小,导致对数组元素的访问出现在数组的范围之外。

    数组下标的取值范围只能预先推断一个值来确定数组的维数,作为秃头程序猿的我们,就得学会检验数组的边界啦。

    一般情况下,数组的越界包括两种:数组下标取值越界与指向数组的指针的指向范围越界。

    第一种:数组下标取值越界
    意思就是访问数组的时候,下标的取值不在我们已经定义好的数组的取值范围内,而访问的是无法获取的内存地址。
    例如,对于数组 int a[3],它的下标取值范围是[0,2](即a[0]、a[1] 与 a[2])。如果我们的取值不在这个范围内(如 a[3]),就会发生越界错误。贴个代码看看:

    int a[3];
    for(int i=0;i<4;i++)
        a[i]=i;
    for(int i=0;i<4;i++)
    	cout<<a[i]; 
    

    以上代码是错误的,因为我们定义数组长度为3,那么数组就为a[0]、a[1]、a[2],然而在for循环中i的循环条件为i=0且i<4,显然可以有0、1、2、3这四种取值,大于数组的取值范围,即数组越界了。

    怎么修改?
    把 i<4 改成 i<3 即可。

    第二种:指向数组的指针的指向范围越界
    一般在定义数组时,会返回一个指向第一个变量的头指针,对这个指针进行加减运算可以向前或向后移动这个指针,进而访问数组中所有的变量。但在移动指针时,如果不注意移动的次数和位置,会使指针指向数组以外的位置,导致数组越界。还是贴个代码就明白了:

    int *p;
    int a[5];
    p=a;			//数组a的头指针赋值给指针p
    for(int i=0;i<10;i++)
    {
    	*p=i+10;  
        p++;       //指向下一变量 
    }
    

    以上为错误代码,for 循环会使指针 p 向后移动 10 次,每次都向指针指向的单元赋值。但是,这里数组 a 的下标取值范围是 [0,4](即 a[0]、a[1]、a[2]、a[3] 与 a[4])。因此,后 5 次的操作会对未知的内存区域赋值,导致系统发生错误。

    正确的操作应该是指针移动的次数与数组中的变量个数相同

    怎么修改?
    把 i<10 改成 i<5 即可。

    以上是本蒟蒻一点小总结,希望对各位兄台有帮助(溜

    更多相关内容
  • 主要介绍了C/C++ 避免数组越界的方法,文中讲解非常细致,代码帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • IOS防止数组越界

    2017-11-17 10:34:27
    移动开发中会经常遇到数组越界问题,导致程序闪退,导致应用界面不友好。我们可以从根本上解决数组越界导致的程序闪退
  • 数组越界异常

    2014-07-03 11:26:31
    用try…catch…finally写一个捕捉数组越界的异常例子。
  • 关注、星标公众号,直达精彩内容ID:技术让梦想更伟大作者:李肖遥所谓的数组越界,简单地讲就是指数组下标变量的取值超过了初始定义时的大小,导致对数组元素的访问出现在数组的范围之外,这类错误...

    关注、星标公众号,直达精彩内容

    ID:技术让梦想更伟大

    作者:李肖遥

    所谓的数组越界,简单地讲就是指数组下标变量的取值超过了初始定义时的大小,导致对数组元素的访问出现在数组的范围之外,这类错误也是 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++)
     4{
     5    a[i] = i;
     6}
     7for(i=0;i<4;i++)
     8{
     9    printf("a[%d]=%d\n",i,a[i]);
    10}
    

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

     1int a[3];
     2int i=0;
     3for(i=0;i<3;i++)
     4{
     5    a[i] = i;
     6}
     7for(i=0;i<3;i++)
     8{
     9    printf("a[%d]=%d\n",i,a[i]);
    10}
    

    指向数组的指针的指向范围越界

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

     1int i;
     2int *p;
     3int a[5];
     4/*数组a的头指针赋值给指针p*/
     5p=a;
     6for(i=0;i<10;i++)
     7{
     8    /*指针p指向的变量*/
     9    *p=i+10;
    10    /*指针p下一个变量*/
    11    p++;
    12}
    

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

     1int i;
     2int *p;
     3int a[5];
     4/*数组a的头指针赋值给指针p*/
     5p=a;
     6for(i=0;i<5;i++)
     7{
     8    /*指针p指向的变量*/
     9    *p=i+10;
    10    /*指针p下一个变量*/
    11    p++;
    12}
    

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

     1#define PASSWORD "123456"
     2int Test(char *str)
     3{
     4    int flag;
     5    char buffer[7];
     6    flag=strcmp(str,PASSWORD);
     7    strcpy(buffer,str);
     8    return flag;
     9}
    10int main(void)
    11{
    12    int flag=0;
    13    char str[1024];
    14    while(1)
    15    {
    16        printf("请输入密码:  ");
    17        scanf("%s",str);
    18        flag = Test(str);
    19        if(flag)
    20        {
    21            printf("密码错误!\n");
    22        }
    23            else
    24            {
    25                printf("密码正确!\n");
    26            }
    27    }
    28    return 0;
    29}
    

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

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

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

     1请输入密码:12345
     2密码错误!
     3请输入密码:123456
     4密码正确!
     5请输入密码:1234567
     6密码正确!
     7请输入密码:aaaaaaa
     8密码正确!
     9请输入密码:0123456
    10密码错误!
    11请输入密码:
    

    在示例代码中,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};
    

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

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

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

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

    1#define MAX 10
    2…
    3int 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
     2#define MAX1 15
     3#define MAX2 6
     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};
     8    int c[MAX2]={1,2,3,4,5,[MAX2-5]=6,7,8,9,10};
     9    int i=0;
    10    int j=0;
    11    int z=0;
    12    printf("a[MAX]:\n");
    13    for(i=0;i<MAX;i++)
    14    {
    15        printf("a[%d]=%d ",i,a[i]);
    16    }
    17    printf("\nb[MAX1]:\n");
    18    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++)
    24    {
    25        printf("c[%d]=%d ",z,c[z]);
    26    }
    27    printf("\n");
    28    return 0;
    29}
    

    运行结果为:

    1a[MAX]:
    2a[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]:
    4b[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{
     4    int *arr=NULL;
     5    arr=(int *)malloc(sizeof(int)*ARRAY_NUM);
     6    if(arr!=NULL)
     7    {
     8        arr[num]=value;
     9    }
    10    else
    11    {
    12        /*处理arr==NULL*/
    13    }
    14    return arr;
    15}
    

    从上面的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    {
     7        arr=(int *)malloc(sizeof(int)*ARRAY_NUM);
     8        if(arr!=NULL)
     9        {
    10            arr[num]=value;
    11        }
    12        else
    13        {
    14            /*处理arr==NULL*/
    15        }
    16    }
    17    return arr;
    18}
    

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

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

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

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

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

     1int *TestArray(size_t num,int value)
     2{
     3    int *arr=NULL;
     4    /*越界检查(越上界)*/
     5    if(num<ARRAY_NUM)
     6    {
     7        arr=(int *)malloc(sizeof(int)*ARRAY_NUM);
     8        if(arr!=NULL)
     9        {
    10            arr[num]=value;
    11        }
    12        else
    13        {
    14            /*处理arr==NULL*/
    15        }
    16    }
    17    return arr;
    18}
    

    获取数组的长度时不要对指针应用 sizeof 操作符

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

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

     1/*若此时max定义为intmax();*/
     2sizeof(max)
     3/*若此时arr定义为char arr[MAX],且MAX未知*/
     4sizeof(arr)
     5/*不能够用于void类型*/
     6sizeof(void)
     7/*不能够用于位字段*/
     8struct S
     9{
    10    unsigned int f1 : 1;
    11    unsigned int f2 : 5;
    12    unsigned int f3 : 12;
    13};
    14sizeof(S.f1);
    

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

     1void Init(int arr[])
     2{
     3    size_t i=0;
     4    for(i=0;i<sizeof(arr)/sizeof(arr[0]);i++)
     5    {
     6        arr[i]=i;
     7    }
     8}
     9int main(void)
    10{
    11    int i=0;
    12    int a[10];
    13    Init(a);
    14    for(i=0;i<10;i++)
    15    {
    16        printf("%d\n",a[i]);
    17    }
    18    return 0;
    19}
    

    从表面看,上面代码的输出结果应该是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]=i;
     7    }
     8}
     9int main(void)
    10{
    11    int i=0;
    12    int a[10];
    13    Init(a,10);
    14    for(i=0;i<10;i++)
    15    {
    16        printf("%d\n",a[i]);
    17    }
    18    return 0;
    19}
    

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

     1void Init(int (*arr)[10])
     2{
     3    size_t i=0;
     4    for(i=0;i< sizeof(*arr)/sizeof(int);i++)
     5    {
     6        (*arr)[i]=i;
     7    }
     8}
     9int main(void)
    10{
    11    int i=0;
    12    int a[10];
    13    Init(&a);
    14    for(i=0;i<10;i++)
    15    {
    16        printf("%d\n",a[i]);
    17    }
    18    return 0;
    19}
    

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

    
    推荐阅读:
    嵌入式编程专辑Linux 学习专辑C/C++编程专辑
    Qt进阶学习专辑关注微信公众号『技术让梦想更伟大』,后台回复“m”查看更多内容;扫描下方微信,加作者微信进技术交流群,请先自我介绍喔。
    
    展开全文
  • 这篇文章主要介绍了浅析C语言编程中的数组越界问题,通过内存空间来讨论其导致的程序崩溃问题,需要的朋友可以参考下。
  • PWN入门之数组越界-附件资源
  • 数组越界处理、Runtime处理、分类处理,使用不同的方法
  • 数组越界会发生什么

    千次阅读 多人点赞 2021-09-14 21:11:20
    文章目录一、数组越界会发生什么二、 数组越界详解 一、数组越界会发生什么 C语言非常重视运行时的效率,所以没有进行数组越界检查,而C++继承了C的效率要求,自然也不做数组越界检查。(检查数据越界,编译器就必须...

    一、数组越界会发生什么

    C语言非常重视运行时的效率,所以没有进行数组越界检查,而C++继承了C的效率要求,自然也不做数组越界检查。(检查数据越界,编译器就必须在生成的目标代码中加入额外的代码用于程序运行时检测下标是否越界,这就会导致程序的运行速度下降)。看下面一段代码:

    #define _CRT_SECURE_NO_WARNINGS   1
    #include<iostream>
    using namespace std;
    int main()
    {
    	int arr[5] = { 1, 2, 3, 4, 5 };
    	for (int i = 0; i <= 5; i++)
    	{
    		cout << i << " " << endl;
    	}
    	cout << arr[6] << endl;
    	cout << arr[7] << endl;
    	return 0;
    }
    

    在这里插入图片描述
    第一行输出结果是arr[0]、arr[1]、arr[2]、arr[3]、arr[4]的值,第二行分别输出它们两个个的地址。数组越界后,会自动接着前面那块内存往后写,这样带来的将会是一系列安全问题。因为界外的内存不确定是否已经存放了东西,如果不凑巧存放着比较重要的数据,那么数组越界后将会把这块内存上的重要数据替换掉,后果可想而知。

    对于数组越界问题,不同编译器或许有不同的处理方案,C/C++标准中仅是对界内访问做了明确的规定,而访问界外数据时却没有说怎么处理。总结一下:

    • 不检查下标是否越界可以有效提高程序运行的效率,因为如果你检查,那么编译器必须在生成的目标代码中加入额外的代码用于程序运行时检测下标是否越界,这就会导致程序的运行速度下降,所以为了程序的运行效率,C/C++才不检查下标是否越界。
    • 不检查下标是为了给程序员更大的空间,也为指针操作带来更多的方便。如果有这个检查的话指针的功能将会大大被削弱,C的数组标识符,里面并没有包含该数组长度的信息,只包含地址信息,所以语言本身无法检查,只能通过编译器检查,而早期的C语言编译器也不对数组越界进行检查,只能由程序员自己检查确保。
    • 如果数组下标越界了,那么它会自动接着那块内存往后写。想了一下明白了,以前说不允许数组下标越界,并不是因为界外没有存储空间,而是因为界外的内容是未知的。也就是说如果界外的空间暂时没有被利用,那么我们可以占用那块内存,但是如果之前界外的内存已经存放了东西,那么我们越界过去就会覆盖那块内存,则有可能会导致错误的产生或是程序最终的运行结果出错。

    二、 数组越界详解

    阅读下面代码,并分析导致其结果的原因(以下分析基于VS环境的调试):

    #include <stdio.h>
    #include<stdlib.h>
    int main()
    {
    	int i = 0;
    	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };  //拥有10个元素的整型数组
    	for (i = 0; i <= 12; i++)   //循环13次,越界访问
    	{
    		arr[i] = 0;
    		printf("Hello World.\n");
    	}
    	system("pause");
    	return 0;
    }
    

    分析:整型数组arr有10个元素,for循环13次,导致数组越界访问。运行程序结果显示如下如图所示,“Hello World”在屏幕循环打印,陷入死循环中。
    在这里插入图片描述
    在这里插入图片描述
    i 从0加至9,循环10次,在屏幕上打印10次“Hello World”,并将数组arr中的全部内容置为0。
    在这里插入图片描述
    i 加至10和11时,越界访问了arr[10]和arr[11],并将arr[10]和arr[11]置为0,当i加至12时将arr[12]也置为0,此时发现 i 也被置为0。
    在这里插入图片描述
    细心的读者就可能会发现,在i加至10、11、12时arr[12]中的内容也随之被改为10、11、12,即图中绿色标记处。那么问题又来了为什么 i 的改变导致arr[12]的改变呢?
      观察 i 的地址和arr[12]的地址如下图,i 的地址和arr[12]的地址均是 0x 00 dd fe ec ,这也就解释了为什么 i 的改变会导致arr[12]的改变。

    在这里插入图片描述
    这就能解释清楚为什么数组越界会导致程序陷入死循环:

    for循环循环13次(i 从0加至12),数组arr下标0至9,当 i = 10、11、12 时,越界访问数组,因为 i 的地址和arr[12]的地址相同,是同一变量空间,当 i = 12 时,将arr[12] 置为0,也就是将 i 置为0,因此for循环中的条件2永远成立,也就是说 i <=12 恒成立,所以程序陷入死循环中。

    上述分析可知 i 的地址和 arr[12] 的地址相同,是同一变量空间,究其根源就得知道计算机中内存是如何分布的。首先的清楚以下几个知识点:
         1. 生命周期:变量的作用范围,变量的创建到变量的销毁之间的时间段。
         2. 内存:内存储器的存储量,一个数据得占用一块物理空间,逻辑的东西必须有物理的东西来支持。而存储器在一般电脑上是:寄存器-> 缓存->内存->硬盘。
         3. 栈区(stack):空间小,系统自动创建销毁。生长方向是由高地址向低地址生长。
        4. 堆区(heap):程序员手动开辟,手动释放,程序结束时可能由 OS 回收。使用关键字malloc / new,free / delete对其开辟释放空间,每个人电脑的空间都是有限的。生长方向是由低地址向高地址生长。
        5. 静态区( static):内容在总个程序的生命周期内都存在,由编译器在编译的时候分配、存储。
    在这里插入图片描述

    究其根源为什么 i 和 arr[12] 是同一变量空间

    局部变量 i 和 arr 在栈区上被使用,因为栈区的生长方向是高地址向低地址生长,所以栈区是先使用高地址处的空间,后使用低地址处的空间,又因为数组随着下标的增长地址由低向高变化,当越界访问适当时,就会访问到变量 i ,执行arr[i]=0;后就会将 i 置为0,导致程序陷入死循环中。栈区的分布如图所示。
    在这里插入图片描述
    修改:for循环中的循环条件为 i<=11 时,不会越界访问到变量 i ,就不会陷入死循环中,系统会提示报错信息。

    for (i = 0; i <= 11; i++)
    {
    arr[i] = 0;
    printf(“Hello World.\n”);
    }

    在这里插入图片描述
    对比:以上是在VS2013上进行调试和编译的,在不同的编译器死循环的位置可能不尽相同。在VC6.0中测试for(i=0;i<=10;i++)程序陷入死循环,在Linux的gcc中测试for(i=0;i<=11;i++)程序陷入死循环。那么在不同编译器下的内存布局如下图所示。
    在这里插入图片描述

    展开全文
  • 数组越界在缓存区溢出中占据重要位置,如何检测数组越界错误是一个重要且极具意义的课题。针对该课题,给出一种对C语言数组越界进行运行时验证的方法。分析了数组越界的错误类型,根据这些类型分别研究了数组越界的...
  • MFC的表格框架CGrdCtrl对表格插入一列时调用 CGridCtrl::InsertColumn出现 vector subscript out of range数组越界异常的解决办法。
  • C++如何避免数组越界

    2021-11-24 14:08:38
    相信很多小伙伴在进行C语言学习和开发过程中都会遇到一个常见的bug,那就是数组越界,对于数组越界其主要是可能影响到正常的程序逻辑,其非常容易伪装成其他问题进而表现出来,比如由于越界篡改了相关数据,其暴露...

    相信很多小伙伴在进行C语言学习和开发过程中都会遇到一个常见的bug,那就是数组越界,对于数组越界其主要是可能影响到正常的程序逻辑,其非常容易伪装成其他问题进而表现出来,比如由于越界篡改了相关数据,其暴露的现场就是相应数据被改后的现象,这样几乎无法直接从现象找到越界的位置。

    那么对于大部分优秀的C语言开发者而言,更多的是养成了良好的编程习惯,对于数组越界的访问变量进行防御性限制,从而防止越界访问的问题。当然对于要求编写高效的代码,就需要工程师们对代码进行严格的把控,以降低越界风险。

    然而C++作为一种带面向对象属性的编程语言,也认为是C语言的升级版本,那是否存在一种不错的方式来解决该问题,让开发者们把更多的注意力花在设计和代码逻辑上来呢?

    当然是有的,大部分情况下,都会采用数组类代替原生的数组类来进行开发与编写,那么下面就简单演示一下数组类是如何最大程度上限制开发人员数组越界的。

    参考代码如下:

    #include<iostream>
    using namespace std;
    
    template <class type>
    class cArray
    {
       public:
            cArray(int size); //构造函数
            ~cArray();    //析构函数
            type & operator[](int i);//重载[]运算符 
        private:
            int length;
            type *a;
    };
    
    //构造函数定义
    template <class type>
    cArray<type>::cArray(int size)
    {
        a = new type[size];   //动态申请内存
        if(!a)
        {
            cout<<"动态空间申请失败!"<<endl;
            exit(1);
        }
    
        //获得申请的内存长度
        length = size;
    
        //重新初始化各个成员
        for(int i = 0;i < size ;i++)
        {
            a[i] = 0;
        }
    }
    
    //[]操作符重载
    template <class type>
    type & cArray<type>::operator[](int i)
    {
        if(i < 0 || i > length - 1)//防止越界 
        {
            cout<<"array["<<i<<"]越界并退出程序!\n";
            exit(2);
        }
    
        return a[i];
    }
    
    //析构函数处理
    template <class type>
    cArray<type>::~cArray()
    {
        delete [] a; //释放构造函数申请的资源
    }
    
    //主测试函数
    int main(void)
    {    
        cArray<int> array1(10);
        cArray<double> array2(5);
    
        for(int i = 0;i < 10;i++)
        {
            array1[i] = i;
        }
    
        for(int i = 0;i < 5;i++)
        {
            array2[i] = i+0.1;
        }
    
        array1[20] = 10; //数组越界测试
    
        return 0;
    }
    

    如上程序通过类模板构造了一个数组模板类,通过构造函数自动分配内存、析构函数释放不用内存、重载运算符[]。在main函数中应用该类与原生数组的使用几乎一个样。

    当然效率上相比原生数组大有损伤,目前对于大部分应用是可以接受的,比如可以通过相应的调用接口来监控数组的使用情况,比如当访问array有越界行为的时候,通过[]重构监控和判断,并进行合理的拦截,这样也就在一定程度山规避掉了数组越界的风险。

    转载自:原文

    展开全文
  • 数组越界问题

    2021-02-25 13:25:21
    而且,很多计算机病毒也正是利用到了代码中的数组越界可以访问非法地址的漏洞,来攻击系统,所以写代码的时候一定要警惕数组越界。 但并非所有的语言都像C一样,把数组越界检查的工作丢给程序员来做,像Java本身就会...
  • C++数组越界问题

    2021-11-16 10:54:19
    C++数组越界内存地址分配数组时间复杂度访问越界问题 内存地址分配 计算机中会给每个内存单元分配一个地址,计算机通过地址来访问内存中的数据,当计算机需要随机访问数组中的某个元素时,它会首先通过下面的寻址...
  • C语言数组越界问题

    2021-09-19 08:35:11
    首先C语言数组越界我们都知道,当我们定义了一个arr[5]数组,首先我们要知道C语言对数组越界访问不会进行检查,也就是说我们访问越界的话,一般不会发生报错。但是如果我们越界的同时,修改区间的值,就会编译通不过...
  • 最近在调查内存泄漏和程序不定期crash的问题,其中有一个横展开观点是:对数组越界写入导致破坏程序堆栈导致的crash.原因是什么,首先必须了解内存的布局,如下图:自底向上,内存中依次存放着只读的程序代码和数据...
  • } 墨菲定律与 IndexOutOfBoundsException(数组越界异常) 今天维护又反馈了一问题过来,查询试卷时报数组越界异常: 2017-02-28 10:45:24,827[ERROR] HttpException[10.32.111.7:60446:2D07867BE ... 使用EasyPOI导入...
  • 动态数组越界问题

    2021-02-26 09:14:08
    动态数组越界 当我们使用动态数组或者其他需要动态创建的对象时,就需要用到堆内存,既然是数组,那就不免会有越界的情况发生。让我们来观察下面几行代码: int* newMem = (int*)malloc(400); memset(newMem, 0xff...
  • 文章目录数组越界是我调试bug时遇到最多的问题二、数组越界通常会导致以下几个问题:1 直接进HardFault2.不进hardfault 不出错3 不进hardfault 导致内存错误 数组越界是我调试bug时遇到最多的问题 二、数组越界通常...
  • 数组越界操作是什么原因

    千次阅读 2021-05-23 09:00:50
    满意答案一、什么是数组访问越界? 我们通过数组的下标来得到数组内指定索引的元素。这称作对数组的访问。 如果一个数组定义为有n个元素,那么,对这n个元素(下标为0 到 n-一的元素)的访问都合法,如果对这n个元素...
  • 数组越界如何解决呢?

    千次阅读 2021-03-10 00:09:14
    题目:读入两个整数m,n,输出一个m行n列的矩阵,这个矩阵是1~mn这些自然数按照右、下、左、上螺旋填入的结果。...注释块的解释:下面两个for循环 在目的数组的外层再套-1 如果不在外层套上-1 则数组越界?...
  • java字符数组越界

    2021-03-14 10:34:08
    publicstaticStringclassPath=BasicController.class.getClassLoader().getResource("/").getPath(); /** *图片处理并返回服务器路径存储路径给页面 * @return **/ ...不存在:所以分割失败,数组1就索引不到了,越界

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 180,927
精华内容 72,370
关键字:

数组越界

友情链接: Pixel_method.rar