精华内容
下载资源
问答
  • 内存越界

    2018-07-10 00:23:53
    内存越界又称内存访问越界,是指访问了所申请空间之外的内存。如果对越界的内存进行读操作,读取的结果具有随机性且无法预知;如果对越界的内存进行写操作,写入的结果可能会破坏其他数据。、内存越界很难检查出来,...
    • 内存越界又称内存访问越界,是指访问了所申请空间之外的内存。如果对越界的内存进行读操作,读取的结果具有随机性且无法预知;如果对越界的内存进行写操作,写入的结果可能会破坏其他数据。、
    • 内存越界很难检查出来,因为它不属于语法错误,无法通过编译器发现,甚至程序运行初期也不会发生错误,直到某种特定情况下才会由于内存越界导致程序崩溃,此时程序已经运行了一段时间,因此内存越界问题很难检测。
    • 内存越界无法从根本上避免,只能预防。这要求编程人员对操作的内存空间有一个明确的认识,确保只修改程序分配的空间。
    展开全文
  • 内存溢出和内存越界

    万次阅读 2018-04-28 09:29:22
    内存溢出和内存越界的有啥区别呢,还是先看定义。 内存溢出:你要分配的内存超出了系统能给你的,系统不能满足需求,于是产生了溢出 内存越界:你想系统申请一块内存,在使用的这块内存的时候,超过出了你申请的范围...

          ❤️强烈推荐人工智能学习网站❤️ 

          内存溢出和内存越界的有啥区别呢,还是先看定义。

           内存溢出:你要分配的内存超出了系统能给你的,系统不能满足需求,于是产生了溢出

           内存越界:你想系统申请一块内存,在使用的这块内存的时候,超过出了你申请的范围

           它们都属于不恰当的使用了内存,只是形式不同而已,所以产生了2个名词来分别表示它们,下面看一下简答的代码实例。

    内存越界:

    int a[10];
    a[12] = 10

    内存溢出:

    char str[5] = "1234567";

            很简单,只是不要把它们的定义搞混了。

     

     

     

    展开全文
  • 内存越界问题

    千次阅读 2018-04-24 11:04:31
    最近在做视频编码的工作,在PC上调试没有问题,但是移植到嵌入式ARM设备上的时候就出现了内存越界问题。起初也不知道是内存越界的问题,只是程序运行会出现非常异常的情况。在PC机上做测试的时候,在内存映射的时候...

        最近在做视频编码的工作,在PC上调试没有问题,但是移植到嵌入式ARM设备上的时候就出现了内存越界问题。起初也不知道是内存越界的问题,只是程序运行会出现非常异常的情况。在PC机上做测试的时候,在内存映射的时候reqbufs.count 的值大于2 进行数据采集的时候,采集到的图片就会出现有的图片是空的,但是运行的时候也没有出现其他的异常或是错误警告,所以这个问题当时就没有去定位,后来将该程序移植到我ARM开发板的时候,问题就出来了。运行的时候出现下面的错误:

    *** glibc detected *** ./test: free(): invalid next size (normal): 0x01f72018 ***
    ======= Backtrace: =========
    /lib/libc.so.6(+0x70188)[0xb6e9f188]
    /lib/libc.so.6(cfree+0x98)[0xb6ea4c80]
    /lib/libc.so.6(fclose+0x1b8)[0xb6e8d968]
    ./test[0x8f54]
    ./test[0x903c]
    ./test[0x91f8]
    ./test[0x93a4]
    /lib/libc.so.6(__libc_start_main+0x114)[0xb6e44544]
    ======= Memory map: ========
    00008000-0000a000 r-xp 00000000 00:0a 206        /tmp/test
    00011000-00012000 rwxp 00001000 00:0a 206        /tmp/test
    01f72000-01f93000 rwxp 00000000 00:00 0          [heap]
    b6b00000-b6b21000 rwxp 00000000 00:00 0 
    b6b21000-b6c00000 ---p 00000000 00:00 0 
    b6cdc000-b6d4d000 rwxs 00000000 00:05 122        /dev/video0
    b6d4d000-b6dbe000 rwxs 00000000 00:05 122        /dev/video0
    b6dbe000-b6e2f000 rwxs 00000000 00:05 122        /dev/video0
    b6e2f000-b6f68000 r-xp 00000000 1f:02 534        /lib/libc-2.11.1.so
    b6f68000-b6f70000 ---p 00139000 1f:02 534        /lib/libc-2.11.1.so
    b6f70000-b6f72000 r-xp 00139000 1f:02 534        /lib/libc-2.11.1.so
    b6f72000-b6f73000 rwxp 0013b000 1f:02 534        /lib/libc-2.11.1.so
    b6f73000-b6f76000 rwxp 00000000 00:00 0 
    b6f76000-b6f81000 r-xp 00000000 1f:02 520        /lib/libgcc_s.so.1
    b6f81000-b6f88000 ---p 0000b000 1f:02 520        /lib/libgcc_s.so.1
    b6f88000-b6f89000 rwxp 0000a000 1f:02 520        /lib/libgcc_s.so.1
    b6f89000-b6fa8000 r-xp 00000000 1f:02 519        /lib/ld-2.11.1.so
    b6fab000-b6fad000 rwxp 00000000 00:00 0 
    b6fad000-b6fae000 rwxp 00000000 00:00 0 
    b6fae000-b6faf000 r-xp 00000000 00:00 0          [sigpage]
    b6faf000-b6fb0000 r-xp 0001e000 1f:02 519        /lib/ld-2.11.1.so
    b6fb0000-b6fb1000 rwxp 0001f000 1f:02 519        /lib/ld-2.11.1.so
    be86a000-be88b000 rw-p 00000000 00:00 0          [stack]
    ffff0000-ffff1000 r-xp 00000000 00:00 0          [vectors]
        知道是内存的错误,但是不知道具体是哪里出了问题,继续定位发现,在我程序调用fclose()和free()就会出现问题,实在是百思不得其解。首先我的文件操作是没有问题的。我单独测试,直接在我程序中插入一段代码,直接打开一个文件,不进行任何的操作,然后再把文件关闭,但是一调用fclose就出现上面的错误。可以确认的是一定是内存分配出了问题,或是数据越界,于是经过一番折腾终于找到了问题点所在。

    我有定义一个结构体

     typedef struct{                                                                                                                  
         void *start;
         int length;
     }BUFTYPE;

     然后定义了一个指针变量
     BUFTYPE *usr_buf;

    参考了网上的代码,在内存分配的时候,代码是这样写的:

    usr_buf = calloc(reqbufs.count, sizeof(usr_buf));

    这问题就出来了,usr_buf 是一个指针变量,它只有4个字节,但是BUFTYPE 结构体是8个字节,这样分配内存就比实际需要的内存小了。如果分配两片内存的话,当调用usr_buf[2]的时候,这时的这个指针就已经越界了,指向了其他的地方。正确的写法应该是:

    usr_buf = calloc(reqbufs.count, sizeof(BUFTYPE));

       在后来调试X264的时候,也是直接参考了网上的代码,同样也出现了内存问题,检查代码后发现它释放内存的的函数是这样写的

    void compress_end(Encoder *en) {
        if (en->picture) {
            x264_picture_clean(en->picture);
            free(en->picture);
            en->picture = 0;
        }
        if (en->param) {
            free(en->param);
            en->param = 0;
        }
        if (en->handle) {
            x264_encoder_close(en->handle);
        }
        free(en);
    }
        可以很明显的看出来是重复释放了。

        虽然出问题部分的代码是参考网上的,但是这些常见的内存错误说不定自己哪天也会犯,这是个经验也是一个教训。有些内存问题是非常隐秘的,非常难以定位,所以养成良好的编码习惯是可以避免很多不必要的问题的。常见的C语言内存错误及对策 


    一、指针没有指向一块合法的内存

    定义了指针变量,但是没有为指针分配内存,即指针没有指向一块合法的内存。浅显的例子就不举了,这里举几个比较隐蔽的例子。

    1、结构体成员指针未初始化
    struct student
    {
       char *name;
       int score;
    }stu,*pstu;
    intmain()
    {
       strcpy(stu.name,"Jimy");
       stu.score = 99;
       return 0;
    }
    很多初学者犯了这个错误还不知道是怎么回事。这里定义了结构体变量stu,但是他没想到这个结构体内部char *name 这成员在定义结构体变量stu 时,只是给name 这个指针变量本身分配了4 个字节。name 指针并没有指向一个合法的地址,这时候其内部存的只是一些乱码。所以在调用strcpy 函数时,会将字符串"Jimy"往乱码所指的内存上拷贝,而这块内存name 指针根本就无权访问,导致出错。解决的办法是为name 指针malloc 一块空间。

    同样,也有人犯如下错误:
    intmain()
    {
       pstu = (struct student*)malloc(sizeof(struct student));
       strcpy(pstu->name,"Jimy");
       pstu->score = 99;
       free(pstu);
       return 0;
    }
    为指针变量pstu 分配了内存,但是同样没有给name 指针分配内存。错误与上面第一种情况一样,解决的办法也一样。这里用了一个malloc 给人一种错觉,以为也给name 指针分配了内存。

    2、没有为结构体指针分配足够的内存
    intmain()
    {
       pstu = (struct student*)malloc(sizeof(struct student*));
       strcpy(pstu->name,"Jimy");
       pstu->score = 99;
       free(pstu);
       return 0;
    }
    为pstu 分配内存的时候,分配的内存大小不合适。这里把sizeof(struct student)误写为sizeof(struct student*)。当然name 指针同样没有被分配内存。解决办法同上。

    3、函数的入口校验
    不管什么时候,我们使用指针之前一定要确保指针是有效的。

    一般在函数入口处使用assert(NULL != p)对参数进行校验。在非参数的地方使用if(NULL != p)来校验。但这都有一个要求,即p 在定义的同时被初始化为NULL 了。比如上面的例子,即使用if(NULL != p)校验也起不了作用,因为name 指针并没有被初始化为NULL,其内部是一个非NULL 的乱码。

    assert 是一个宏,而不是函数,包含在assert.h 头文件中。如果其后面括号里的值为假,则程序终止运行,并提示出错;如果后面括号里的值为真,则继续运行后面的代码。这个宏只在Debug 版本上起作用,而在Release 版本被编译器完全优化掉,这样就不会影响代码的性能。

    有人也许会问,既然在Release 版本被编译器完全优化掉,那Release 版本是不是就完全没有这个参数入口校验了呢?这样的话那不就跟不使用它效果一样吗?

    是的,使用assert 宏的地方在Release 版本里面确实没有了这些校验。但是我们要知道,assert 宏只是帮助我们调试代码用的,它的一切作用就是让我们尽可能的在调试函数的时候把错误排除掉,而不是等到Release 之后。它本身并没有除错功能。再有一点就是,参数出现错误并非本函数有问题,而是调用者传过来的实参有问题。assert 宏可以帮助我们定位错误,而不是排除错误。

    二、为指针分配的内存太小

    为指针分配了内存,但是内存大小不够,导致出现越界错误。
       char *p1 = “abcdefg”;
       char *p2 = (char *)malloc(sizeof(char)*strlen(p1));
       strcpy(p2,p1);
    p1 是字符串常量,其长度为7 个字符,但其所占内存大小为8 个byte。初学者往往忘了字符串常量的结束标志“\0”。这样的话将导致p1 字符串中最后一个空字符“\0”没有被拷贝到p2 中。解决的办法是加上这个字符串结束标志符:
       char *p2 = (char *)malloc(sizeof(char)*strlen(p1)+1*sizeof(char));
    这里需要注意的是,只有字符串常量才有结束标志符。比如下面这种写法就没有结束标志符了:
       char a[7] = {‘a’,’b’,’c’,’d’,’e’,’f’,’g’};
    另外,不要因为char 类型大小为1 个byte 就省略sizof(char)这种写法。这样只会使你的代码可移植性下降。

    三、内存分配成功,但并未初始化

    犯这个错误往往是由于没有初始化的概念或者是以为内存分配好之后其值自然为0。未初始化指针变量也许看起来不那么严重,但是它确确实实是个非常严重的问题,而且往往出现这种错误很难找到原因。

    曾经有一个学生在写一个windows 程序时,想调用字库的某个字体。而调用这个字库需要填充一个结构体。他很自然的定义了一个结构体变量,然后把他想要的字库代码赋值给了相关的变量。但是,问题就来了,不管怎么调试,他所需要的这种字体效果总是不出来。我在检查了他的代码之后,没有发现什么问题,于是单步调试。在观察这个结构体变量的内存时,发现有几个成员的值为乱码。就是其中某一个乱码惹得祸!因为系统会按照这个结构体中的某些特定成员的值去字库中寻找匹配的字体,当这些值与字库中某种字体的某些项匹配时,就调用这种字体。但是很不幸,正是因为这几个乱码,导致没有找到相匹配的字体!因为系统并无法区分什么数据是乱码,什么数据是有效的数据。只要有数据,系统就理所当然的认为它是有效的。

    也许这种严重的问题并不多见,但是也绝不能掉以轻心。所以在定义一个变量时,第一件事就是初始化。你可以把它初始化为一个有效的值,比如:
       int i = 10;
       char *p = (char *)malloc(sizeof(char));
    但是往往这个时候我们还不确定这个变量的初值,这样的话可以初始化为0 或NULL。
       int i = 0;
       char *p = NULL;
    如果定义的是数组的话,可以这样初始化:
       int a[10] = {0};
    或者用memset 函数来初始化为0:
       memset(a,0,sizeof(a));
    memset 函数有三个参数,第一个是要被设置的内存起始地址;第二个参数是要被设置的值;第三个参数是要被设置的内存大小,单位为byte。这里并不想过多的讨论memset 函数的用法,如果想了解更多,请参考相关资料。

    至于指针变量如果未被初始化,会导致if 语句或assert 宏校验失败。这一点,上面已有分析。

    四、内存越界

    内存分配成功,且已经初始化,但是操作越过了内存的边界。这种错误经常是由于操作数组或指针时出现“多1”或“少1”。比如:
    int a[10] = {0};
    for (i=0; i<=10; i++)
    {
       a[i] = i;
    }
    所以,for 循环的循环变量一定要使用半开半闭的区间,而且如果不是特殊情况,循环变量尽量从0 开始。

    五、内存泄漏

    内存泄漏几乎是很难避免的,不管是老手还是新手,都存在这个问题。甚至包括windows,Linux 这类软件,都或多或少有内存泄漏。也许对于一般的应用软件来说,这个问题似乎不是那么突出,重启一下也不会造成太大损失。但是如果你开发的是嵌入式系统软件呢?比如汽车制动系统,心脏起搏器等对安全要求非常高的系统。你总不能让心脏起搏器重启吧,人家阎王老爷是非常好客的。

    会产生泄漏的内存就是堆上的内存(这里不讨论资源或句柄等泄漏情况),也就是说由malloc 系列函数或new 操作符分配的内存。如果用完之后没有及时free 或delete,这块内存就无法释放,直到整个程序终止。

    1、告老还乡求良田
    怎么去理解这个内存分配和释放过程呢?先看下面这段对话:
    万岁爷:爱卿,你为朕立下了汗马功劳,想要何赏赐啊?
    某功臣:万岁,黄金白银,臣视之如粪土。臣年岁已老,欲告老还乡。臣乞良田千亩以荫后世,别无他求。
    万岁爷:爱卿,你劳苦功高,却仅要如此小赏,朕今天就如你所愿。户部刘侍郎,查看湖广一带是否还有千亩上等良田未曾封赏。
    刘侍郎:长沙尚有五万余亩上等良田未曾封赏。
    万岁爷:在长沙拨良田千亩封赏爱卿。爱卿,良田千亩,你欲何用啊?
    某功臣:谢万岁。长沙一带,适合种水稻,臣想用来种水稻。种水稻需要把田分为一亩一块,方便耕种。
    。。。。

    2、如何使用malloc 函数
    不要莫名其妙,其实上面这段小小的对话,就是malloc 的使用过程。malloc 是一个函数,专门用来从堆上分配内存。使用malloc 函数需要几个要求:
    内存分配给谁?这里是把良田分配给某功臣。
    分配多大内存?这里是分配一千亩。
    是否还有足够内存分配?这里是还有足够良田分配。
    内存的将用来存储什么格式的数据,即内存用来做什么?
    这里是用来种水稻,需要把田分成一亩一块。分配好的内存在哪里?这里是在长沙。

    如果这五点都确定,那内存就能分配。下面先看malloc 函数的原型:
       (void *)malloc(int size)
    malloc 函数的返回值是一个void 类型的指针,参数为int 类型数据,即申请分配的内存大小,单位是byte。内存分配成功之后,malloc 函数返回这块内存的首地址。你需要一个指针来接收这个地址。但是由于函数的返回值是void *类型的,所以必须强制转换成你所接收的类型。也就是说,这块内存将要用来存储什么类型的数据。比如:
       char *p = (char *)malloc(100);
    在堆上分配了100 个字节内存,返回这块内存的首地址,把地址强制转换成char *类型后赋给char *类型的指针变量p。同时告诉我们这块内存将用来存储char 类型的数据。也就是说你只能通过指针变量p 来操作这块内存。这块内存本身并没有名字,对它的访问是匿名访问。

    上面就是使用malloc 函数成功分配一块内存的过程。但是,每次你都能分配成功吗?

    不一定。上面的对话,皇帝让户部侍郎查询是否还有足够的良田未被分配出去。使用malloc函数同样要注意这点:如果所申请的内存块大于目前堆上剩余内存块(整块),则内存分配会失败,函数返回NULL。注意这里说的“堆上剩余内存块”不是所有剩余内存块之和,因为malloc 函数申请的是连续的一块内存。

    既然malloc 函数申请内存有不成功的可能,那我们在使用指向这块内存的指针时,必须用if(NULL != p)语句来验证内存确实分配成功了。

    3、用malloc 函数申请0 字节内存
    另外还有一个问题:用malloc 函数申请0 字节内存会返回NULL 指针吗?

    可以测试一下,也可以去查找关于malloc 函数的说明文档。申请0 字节内存,函数并不返回NULL,而是返回一个正常的内存地址。但是你却无法使用这块大小为0 的内存。这好尺子上的某个刻度,刻度本身并没有长度,只有某两个刻度一起才能量出长度。对于这一点一定要小心,因为这时候if(NULL != p)语句校验将不起作用。

    4、内存释放
    既然有分配,那就必须有释放。不然的话,有限的内存总会用光,而没有释放的内存却在空闲。与malloc 对应的就是free 函数了。free 函数只有一个参数,就是所要释放的内存块的首地址。比如上例:
       free(p);
    free 函数看上去挺狠的,但它到底作了什么呢?其实它就做了一件事:斩断指针变量与这块内存的关系。比如上面的例子,我们可以说malloc 函数分配的内存块是属于p 的,因为我们对这块内存的访问都需要通过p 来进行。free 函数就是把这块内存和p 之间的所有关系斩断。从此p 和那块内存之间再无瓜葛。至于指针变量p 本身保存的地址并没有改变,但是它对这个地址处的那块内存却已经没有所有权了。那块被释放的内存里面保存的值也没有改变,只是再也没有办法使用了。

    这就是free 函数的功能。按照上面的分析,如果对p 连续两次以上使用free 函数,肯定会发生错误。因为第一使用free 函数时,p 所属的内存已经被释放,第二次使用时已经无内存可释放了。关于这点,我上课时让学生记住的是:一定要一夫一妻制,不然肯定出错。

    malloc 两次只free 一次会内存泄漏;malloc 一次free 两次肯定会出错。也就是说,在程序中malloc 的使用次数一定要和free 相等,否则必有错误。这种错误主要发生在循环使用malloc 函数时,往往把malloc 和free 次数弄错了。这里留个练习:
    写两个函数,一个生成链表,一个释放链表。两个函数的参数都只使用一个表头指针。

    5、内存释放之后
    既然使用free 函数之后指针变量p 本身保存的地址并没有改变,那我们就需要重新把p的值变为NULL:
       p = NULL;
    这个NULL 就是我们前面所说的“栓野狗的链子”。如果你不栓起来迟早会出问题的。比如:
    在free(p)之后,你用if(NULL != p)这样的校验语句还能起作用吗?例如:
       char *p = (char *)malloc(100);
       strcpy(p, “hello”);
       free(p); /* p 所指的内存被释放,但是p 所指的地址仍然不变*/
       …
       if (NULL != p)
       {
          /* 没有起到防错作用*/
          strcpy(p, “world”); /* 出错*/
       }
    释放完块内存之后,没有把指针置NULL,这个指针就成为了“野指针”,也有书叫“悬垂指针”。这是很危险的,而且也是经常出错的地方。所以一定要记住一条:free 完之后,一定要给指针置NULL。

    同时留一个问题:对NULL 指针连续free 多次会出错吗?为什么?如果让你来设计free函数,你会怎么处理这个问题?

    六、内存已经被释放了,但是继续通过指针来使用

    这里一般有三种情况:
    第一种:就是上面所说的,free(p)之后,继续通过p 指针来访问内存。解决的办法就是给p 置NULL。
    第二种:函数返回栈内存。这是初学者最容易犯的错误。比如在函数内部定义了一个数组,却用return 语句返回指向该数组的指针。解决的办法就是弄明白栈上变量的生命周期。
    第三种:内存使用太复杂,弄不清到底哪块内存被释放,哪块没有被释放。解决的办法是重新设计程序,改善对象之间的调用关系。


    上面详细讨论了常见的六种错误及解决对策,希望读者仔细研读,尽量使自己对每种错误发生的原因及预防手段烂熟于胸。一定要多练,多调试代码,同时多总结经验。











    展开全文
  • 内存越界详解

    千次阅读 2019-02-26 12:01:33
    内存越界是软件系统主要错误之一,其后果往往不可预料且非常严重。更麻烦的是,它出现的时机是随机的,表现出来的症状是随机的,而且造成的后果也是随机的,这会使程序员很难找出这些 Bug 的现象和本质之间的联系,...

    内存越界是软件系统主要错误之一,其后果往往不可预料且非常严重。更麻烦的是,它出现的时机是随机的,表现出来的症状是随机的,而且造成的后果也是随机的,这会使程序员很难找出这些 Bug 的现象和本质之间的联系,从而给 Bug 的定位带来极大的困难。一般情况下,内存越界访问可分如下两种:

    • 读越界,即读了不属于自己的数据。如果所读的内存地址是无效的,程序立刻崩溃;如果所读内存地址是有效的,在读的时候不会马上出现问题,但由于读到的数据是随机的,因此它会造成不可预料的后果。
    • 写越界,又称为缓冲区溢出,所写入的数据对别的程序来说是随机的,它也会造成不可预料的后果。

    避免数组越界

    数组越界错误主要包括数组下标取值越界和指向数组的指针的指向范围越界。

    数组下标取值越界主要是指访问数组时,下标的取值不在已定义好的数组的取值范围,而访问的是无法获取的内存地址。例如 int a[10],此数组 a 的下标取值范围是 [0,9]。若取值不在这个范围,就出现越界错误。

    指向数组的指针的指向范围越界表示当定义的指针 p 若指向了数组的首地址时(即 p=a),若对其不断进行操作 p++,则最后会导致指针 p 指向大于该数组范围的上界,从而使程序访问了数组以外的存储单元,造成数组越界。

    如下面的示例代码所示:

    
     
    1. #define MAX_BUF_SIZE 10
    2. int main(void)
    3. {
    4. int i = 0;
    5. int a[MAX_BUF_SIZE] = { 0 };
    6. for (i = 0; i <= MAX_BUF_SIZE; i++)
    7. {
    8. a[i] = i;
    9. printf("%d", a[i]);
    10. }
    11. return 0;
    12. }

    上面的示例代码就是一个典型的数组下标取值越界。其中,因为 MAX_BUF_SIZE 被定义为 10,所以 int a[MAX_BUF_SIZE] 定义了 10 个元素大小的数组。由于 C 语言中数组的索引是从 0 开始的,所以只能访问 a[0] 到 a[9]。当“i=10”时,访问 a[10] 就造成越界错误。因此,应该修改成如下形式:

    
     
    1. #define MAX_BUF_SIZE 10
    2. int main(void)
    3. {
    4. int i = 0;
    5. int a[MAX_BUF_SIZE] = { 0 };
    6. for (i = 0; i < MAX_BUF_SIZE; i++)
    7. {
    8. a[i] = i;
    9. printf("%d", a[i]);
    10. }
    11. return 0;
    12. }

    除此之外,在设置缓冲区大小时,要考虑各种应用场合,特别是考虑到函数参数的边界条件,按最大的可能分配空间,能够利用程序计算的,尽量自动计算。

    避免 sprintf、vsprintf、strcpy、strcat 与 gets 越界

    前面已经阐述过,C 语言提供的字符串库函数 sprintf、vsprintf、strcpy、strcat 与 gets 等非常危险,很容易导致内存越界,应该尽量使用安全的字符串库函数 snprintf、strncpy、strncat 与 fgets 来替换它们。

    如下面的示例代码所示:

    
     
    1. char buf[250];
    2. sprintf(buf, "*** File:%s Line : %d ****", __FILE__, __LINE__);

    其中,“__FILE__”在预编译时,被编译时的目录名和源文件名代替,但目录和文件名的长度可变,很可能超出 250 字节,从而导致内存越界。因此,应该使用 snprintf 来替换 sprintf 函数,指定缓冲区的大小,确保内存不会越界。如下面的示例代码所示:

    
     
    1. snprintf(buf, MAX_BUF_SIZE - 1, "*** File:%s Line : %d ****", __FILE__, __LINE__);
    2. buf[MAX_BUF_SIZE - 1] = '\0';

    避免memcpy与memset函数长度越界

    对于 memcpy 与 memset 函数,在使用的时候一定要确保长度不要越界。如下面的示例代码所示:

    
     
    1. char a[80];
    2. char b[100];
    3. /*a的长度小于b的长度,发生越界*/
    4. memcpy(a,b,sizeof(b));

    很明显,b 的长度是 100,而 a 长度是 80,执行语句“memcpy(a,b,sizeof(b))”时,由于 a 的长度小于 b 的长度,所以将导致程序内存越界。因此,必须确保 a 的长度大于 b 的长度,又或者是 a 和 b 的长度保持一致。由于是字符串拷贝,因此还可以改用 strncpy 函数。如下面的示例代码所示:

    
     
    1. char a[MAX_BUF_SIZE];
    2. char b[MAX_BUF_SIZE];
    3. strncpy(a, b, MAX_BUF_SIZE);
    4. a[MAX_BUF_SIZE - 1] = '\0';

    避免忽略字符串最后的'\0'字符而导致的越界

    在 C 语言中,字符串是一个以'\0'字符结尾的字符数组。但是,当使用 strlen 库函数来获取字符串的长度时,其长度值并不包含'\0'字符。这就导致我们经常因为不小心而忽略了字符串最后的'\0'字符。

    如下面的示例代码所示:

    
     
    1. int main(void)
    2. {
    3. char * str = "abcdefghijk";
    4. char c[20];
    5. memcpy(c, str, strlen(str));
    6. printf("%s:%d\n", c, strlen(c));
    7. return 0;
    8. }

    在上面的代码中,“strlen(str)”获取的是 str 真实的字符串长度,不包括最后的'\0'字符。因此,当执行“memcpy(c,str,strlen(str))”语句时,并没有将 str 整个字符串复制到 c 中。再加上这里的字符数组 c 并没有进行初始化,所以最后执行“printf("%s:%d\n",c,strlen(c))”语句时,其运行结果将出乎意料,如图 1 所示。



    图 1


    但如果在“strlen(str)”获取的str真实的字符串长度后再加上 1(即包括最后的 '\0' 字符),情况就不一样了,如下面的示例代码所示:

    
     
    1. int main(void)
    2. {
    3. char * str = "abcdefghijk";
    4. char c[20];
    5. memcpy(c, str, strlen(str)+1);
    6. printf("%s:%d\n", c, strlen(c));
    7. return 0;
    8. }

    运行结果为:
    abcdefghijk:11

    除此之外,在使用 strncpy 等安全函数时,当复制字符串到达指定的长度时,不会在目标字符串结尾添加 '\0' 字符,必须手工进行添加 '\0' 字符。当然,可以在申请内存时,将最后一个字节置为 '\0' 字符;也可以在调用 strncpy 函数后,紧接着赋 '\0' 字符。

    展开全文
  • 内存越界访问

    2019-09-06 08:45:57
    文章目录内存越界访问例子 内存越界访问例子 int *a; *a = 0x12345; //为什么是错误的? 当定义int a时,a的值是不定的,有可能指向代码段前面的区域和系统代码段(这些是属于不可读写区间)。例如当a=0x12345时,...
  • 内存泄漏检测和内存越界检测

    千次阅读 2019-05-17 14:13:39
    本程序为内存泄漏和内存越界检测。本文及程序为原创,转发请标注littlezls原创。 欢迎大家相互交流学习。 1. 说明 作为一个编程人员,或许你会需要下面三个问题: 1.由于代码量大,项目复杂, 用系统函数malloc,...
  • 内存越界是软件系统主要错误之一,其后果往往不可预料且非常严重。更麻烦的是,它出现的时机是随机的,表现出来的症状是随机的,而且造成的后果也是随机的,这会使程序员很难找出这些 Bug 的现象和本质之间的联系,...
  • Linux-内存越界

    2020-11-19 20:54:10
    内存越界是程序员比较头疼的问题,尤其在大型项目里,内存越界会导致随机错误或崩溃,不好定位。 1.什么是内存越界 内存越界就是操作内存的地址超出申请内存的范围,比如下面的代码,申请了1 byte内存,但对第二个...
  • 内核里面内存越界问题是一类很常见的错误类型,当然有些也属于异常难调试的问题,这种错误行为会触发内核运行异常,假如越界访问修改了错误的数据区,情况较轻的可能导致应用获取的数据不对;情况严重的,比如修改了...
  • 内存泄露:分配了内存而没有释放,逐渐耗尽内存资源,导致系统崩溃内存越界: 打个比方 就是你有一个500ml的水瓶,然后你倒在瓶里的水大于500ml 那个多余的就会流出来... 1.原理分析经常有些新C++程序员问:C++的...
  • 内存越界问题是项目开发中比较难解决的问题,下面就简单的描述下内存越界的种类、现象及引起的原因。
  • C++内存越界问题请教

    2018-05-08 17:55:21
    C++代码,产生core,内存越界访问,10点半个月,不定期偶现。请教各位大神解答业务代码从#6开始该行代码为字符串拼接
  • 内存问题一直以来都是C/C++开发中比较麻烦的问题,总的来讲,可以分成内存碎片、内存泄漏和内存越界这几类其中,以内存越界最为复杂,而且难以定位。下面我们将通过技术手段逐一分析并解决这三个问题。 一、操作...
  • 内存溢出、内存泄露、内存越界、缓冲区溢出、栈溢出
  • 内存越界问题debug总结

    千次阅读 2018-05-18 17:20:37
    内存越界是一类既麻烦又难解的bug.因为内存的越界发生了之后,1.踩到致命内存,马上崩溃,只知道被踩的内存区域,并不知道是怎么被踩的2.踩了多次,才踩到致命内存,崩溃,同样的,只知道被踩的内存区域,并不知道是...
  • stm32调试内存越界情况

    千次阅读 2019-01-23 17:53:16
    最近项目调试中总是遇到内存越界,现象比较诡异。再此写下记录,以便后续学习。 现象:测试整个流程 莫名其妙的 重启,有的时候不重启但是进入死循环。单步跟踪 有时不在同一个地方进入异常。   调试过程: ...
  • Malloc内存泄露和内存越界问题的研究 2013-03-02 22:59:32 分类: LINUX 原文地址:Malloc内存泄露和内存越界问题的研究 作者:gongcb Malloc内存泄露和内存越界问题的研究 ------内存跟踪与检测篇 ...
  • 在写C/C++程序时,要小心内存泄漏,内存越界访问,但最粗心的也就是这一块;在程序运行过程中,最担心的也就是突然core掉,或程序占用完内存。此时要么DBG产生的core文件,要么是查看日志再对照源代码,假如此时你的...
  • 内存溢出:用户要求系统分配的内存空间超出了系统...内存越界:使用已申请的内存时,超出了内存的界限。 栈溢出:栈满时再做进栈必定产生空间溢出,叫上溢,栈空时再做退栈也产生空间溢出,称为下溢。 ps:典型的,在

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 98,690
精华内容 39,476
关键字:

内存越界