C语言内存（野指针☆）

1.堆

在链表中找接近4字节的空间，发现5字节接近4字节，将5字节给程序。

 

2.静态存储区（编译时就存在）

保存全局变量和静态局部变量

 

3.野指针来源

1）局部指针变量没有初始化；

struct Student

{

    char* name;

    int number;

};

int main()

{

    struct Student s;   //------>未初始化。

    strcpy(s.name, "Delphi Tang"); // OOPS!

    s.number = 99;

    return 0;

}

2）使用已释放的指针

void func(char* p)

{

    printf("%s\n", p);

    free(p); //-------->释放了指针

}

int main()

{

    char* s = (char*)malloc(5);

    strcpy(s, "Delphi Tang"); //内存越界

    func(s);

    printf("%s\n", s); // OOPS!

    return 0;

}

3)指针指向的变量在指向前被销毁

函数返回后，fun函数有可能 被释放栈，s指向位置未知，就产生野指针

char* func()

{

    char p[] = "Delphi Tang";

    return p;

}

int main()

{

    char* s = func();

    printf("%s\n", s); // OOPS!

    return 0;

}

4.非法内存操作实例

1）结构体未初始化

struct Demo

{

     int* p;

};

int main()

{

struct Demo d1;

for(int i=0; i<10; i++)

    {

        d1.p[i] = 0; // OOPS!

}

}

结构体初始化方法struct  A_stru{      int   a;   int   *p;    }x;  

 memset(&x,   0,   sizeof(x))       或者    memset(&x,   0,   sizeof(struct   A_stru))   

2)没有为结构体指针分配足够的内存（越界）

 

d2.p = (int*)calloc(5, sizeof(int));

    

    for(i=0; i<10; i++)

    {

        d2.p[i] = i; // OOPS!

}

 

3)内存分配成功，但未初始化

 

Int main（）

{

char* s = (char*)malloc(10);

printf(s); // OOPS!

free(s);

return 0;

}

 

4)数组越界

 

void f(int a[10])

{

    int i = 0;

    for(i=0; i<10; i++)

    {

        a[i] = i; // OOPS!

        printf("%d\n", a[i]);

    }

}

 

int main()

{

    int a[5];

    f(a);

return 0;

}

 

 

 

 

 

 

 

5)内存泄漏（最好单入口单出口）

 

void f(unsigned int size)

{

    int* p = (int*)malloc(size*sizeof(int));

    int i = 0;

    

    if( size % 2 != 0 )

    {

        return; // OOPS!未free(p)

}

    for(i=0; i<size; i++)

    {

        p[i] = i;

        printf("%d\n", p[i]);

    }

    free(p);

}

int main()

{ f(9); f(10);   return 0; }

 

6)多次指针释放（谁申请谁释放）

 

void f(int* p, int size)

{

    int i = 0;

    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));

    f(p, 5);

    free(p); // OOPS!

    return 0;

}

 

 

 

 

7）使用已释放的指针

void f(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 i = 0;

    f(p, 5);

    for(i=0; i<5; i++)

    {

        p[i] = i; // OOPS!

    }

    return 0;

}

5.规范

1）malloc申请后使用NULL，防止使用NULL指针

int* p = (int*)malloc(5 * sizeof(int));

if( p!=NULL)

{ //do something

}

Free(p);

2)牢记数组长度，防止越界（考虑使用柔性数组）

 

 

3）动态申请和释放相匹配（谁申请谁释放）

 

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