C 语言

关注公众号 jb51net

关闭
首页 > 软件编程 > C 语言 > C语言 内存操作

C语言深入讲解内存操作问题

作者:清风自在 流水潺潺

程序运行的目的是为了得到特定的结果,计算机本质上是用于计算的,既然是用于计算,就需要参与计算的数据,那这些数据就存储在内存中,计算之前参与运算的数据以及运算之后得到的数据,都存储在内存中,所以对内存操作的掌握就尤为重要,下面我们一起来看看

一、野指针

二、野指针的由来

        下面看一个示例:

#include <stdio.h>
#include <malloc.h>
 
 
int main()
{
    int* p1 = (int*)malloc(40);
    int* p2 = (int*)1234567;    //p2 是一个野指针
    int i = 0;
    
    printf("%p\n", p1);
    for(i=0; i<40; i++)
    {
        *(p1 + i) = 40 - i; //由于指针运算产生了野指针,改写了非法内存地址
    }
 
    free(p1); 
    
    printf("%p\n", p1);
    
    for(i=0; i<40; i++)
    {
        p1[i] = p2[i];  //使用已经释放了的内存空间
    }
    
    return 0;
}
 

        输出结果如下: 

         两个打印语句打印出来的地址值是完全相同的,这说明 free() 函数只负责释放 p1 所指向的内存空间,但是不负责将 p1 重置为空指针,或者说重置为任何地址值。

        可以做以下修改:

#include <stdio.h>
#include <malloc.h>
 
int arr[40] = {1, 2, 3, 4, 5, 6, 7};
 
int main()
{
    int* p1 = (int*)malloc(40 * sizeof(int));
    int* p2 = arr;    
    int i = 0;
    
    printf("%p\n", p1);
    for(i=0; i<40; i++)
    {
        *(p1 + i) = 40 - i; 
    }
 
    free(p1); 
    p1 = NULL;
    
    printf("%p\n", p1);
    
    for(i=0; i<40; i++)
    {
        p1[i] = p2[i];  //使用已经释放了的内存空间
    }
    
    return 0;
}

         输出结果如下:

         这里注意一个技巧,将释放之后的指针立即赋值成空指针。

三、基本原则

        下面再来看一个示例:

#include <stdio.h>
#include <string.h>
#include <malloc.h>
 
struct Student
{
    char* name;
    int number;
};
 
char* func()
{
    char p[] = "AutumnZe";
    
    return p;
}
 
void del(char* p)
{
    printf("%s\n", p);
    
    free(p);
}
 
int main()
{
    struct Student s;   //由于没有初始化,产生了野指针
    char* p = func();   //产生了野指针
    
    strcpy(s.name, p);  //使用野指针,name 成员保存的地址值完全不知道
    
    s.number = 99;
    
    p = (char*)malloc(5);
    
    strcpy(p, "AutumnZe");   //产生内存越界,操作了野指针
    
    del(p);
    
    return 0;
}

        输出结果如下:

四、小结-上 

五、常见的内存错误

        下面看一个示例:

#include <stdio.h>
#include <malloc.h>
 
void test(int* p, int size)
{
    int i = 0;
    
    for(i=0; i<size; i++)
    {
        printf("%d\n", p[i]);
    }
    
    free(p);    //这里多释放了一次内存
}
 
void func(unsigned int size)
{
    int* p = (int*)malloc(size * sizeof(int));
    int i = 0;
    
    if( size % 2 != 0 )
    {
        return; 
    }
    
    for(i=0; i<size; i++)
    {
        p[i] = i;
        printf("%d\n", p[i]);
    }
    
    free(p);
}
 
int main()
{
    int* p = (int*)malloc(5 * sizeof(int));
    
    test(p, 5);
    
    free(p); 
    
    func(9);
    func(10);
       
    return 0;
}
 

          输出结果如下,可以看到程序崩溃了:

0
0
0
0
0
*** glibc detected *** ./a.out: double free or corruption (fasttop): 0x0969e008 ***
======= Backtrace: =========
/lib/libc.so.6(+0x6c0c1)[0x27b0c1]
/lib/libc.so.6(+0x6d930)[0x27c930]
/lib/libc.so.6(cfree+0x6d)[0x27fa1d]
./a.out[0x804851f]
/lib/libc.so.6(__libc_start_main+0xe7)[0x225ce7]
./a.out[0x8048391]
======= Memory map: ========
0013c000-00158000 r-xp 00000000 08:02 4629       /lib/ld-2.12.1.so
00158000-00159000 r--p 0001b000 08:02 4629       /lib/ld-2.12.1.so
00159000-0015a000 rw-p 0001c000 08:02 4629       /lib/ld-2.12.1.so
0020e000-0020f000 r-xp 00000000 00:00 0          [vdso]
0020f000-00366000 r-xp 00000000 08:02 4645       /lib/libc-2.12.1.so
00366000-00368000 r--p 00157000 08:02 4645       /lib/libc-2.12.1.so
00368000-00369000 rw-p 00159000 08:02 4645       /lib/libc-2.12.1.so
00369000-0036c000 rw-p 00000000 00:00 0 
00dbf000-00dd9000 r-xp 00000000 08:02 102        /lib/libgcc_s.so.1
00dd9000-00dda000 r--p 00019000 08:02 102        /lib/libgcc_s.so.1
00dda000-00ddb000 rw-p 0001a000 08:02 102        /lib/libgcc_s.so.1
08048000-08049000 r-xp 00000000 08:05 525125     /home/delphi/a.out
08049000-0804a000 r--p 00000000 08:05 525125     /home/delphi/a.out
0804a000-0804b000 rw-p 00001000 08:05 525125     /home/delphi/a.out
0969e000-096bf000 rw-p 00000000 00:00 0          [heap]
b7600000-b7621000 rw-p 00000000 00:00 0 
b7621000-b7700000 ---p 00000000 00:00 0 
b77db000-b77dc000 rw-p 00000000 00:00 0 
b77e9000-b77ec000 rw-p 00000000 00:00 0 
bfc94000-bfcb5000 rw-p 00000000 00:00 0          [stack]
已放弃

        如果把多余的 free() 注释掉,程序就能正常运行了。

void test(int* p, int size)
{
    int i = 0;
    
    for(i=0; i<size; i++)
    {
        printf("%d\n", p[i]);
    }
    
    //free(p);    //这里多释放了一次内存
}

        输出结果如下:

        接上面的例子,讨论一下 free 问题,代码如下:

#include <stdio.h>
#include <malloc.h>
 
void test(int* p, int size)
{
    int i = 0;
    
    for(i=0; i<size; i++)
    {
        printf("%d\n", p[i]);
    }
    
    free(p);
}
 
int main()
{
    int* p = (int*)malloc(5 * sizeof(int));
    int a[2];
    
    test(a, 2);
       
    return 0;
}
 

         输出结果如下:

         因为 test(a, 2);  调用 test() 函数时 p 所指向的内存空间是栈上面的空间,但是 free 函数的作用是释放堆上面的空间,所以肯定会发生段错误。

        下面再来看一个例子:

#include <stdio.h>
#include <malloc.h>
 
struct Demo
{
    char* p;
};
 
int main()
{
    struct Demo d1;
    struct Demo d2;
    
    char i = 0;
    
    for(i='a'; i<'z'; i++)
    {
        d1.p[i] = 0; 
    }
    
    d2.p = (char*)calloc(5, sizeof(char));
    
    printf("%s\n", d2.p);
    
    for(i='a'; i<'z'; i++)
    {
        d2.p[i] = i; //内存越界
    }
    
    free(d2.p);
    
    return 0;
}

         输出结果如下:

         结构体变量里面包含指针,但是没有初始化,就会变成野指针。所以  d1.p[i] = 0; 就会产生 bug。

六、内存操作的规则

动态内存申请之后,应该立即检查指针值是否为 NULL,防止使用 NULL 指针

 free 指针之后必须立即赋值为 NULL

 任何与内存操作相关的函数都必须带长度信息

 malloc 操作和 free 操作必须匹配,防止内存泄露和多次释放。

七、小结-下 

内存错误的本质源于指针保存的地址为非法值

内存泄漏源于 malloc 和 free 不匹配

避免内存泄漏:哪个函数里面进行的 malloc ,就在哪个函数里面 free,不要跨函数去释放动态的内存空间。

到此这篇关于C语言深入讲解内存操作问题的文章就介绍到这了,更多相关C语言 内存操作内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

您可能感兴趣的文章:
阅读全文