野指针与非法内存操作

野指针

野指针通常是因为指针变量中保存的值不是一个合法的内存地址而造成的。

合法的内存地址：

1.在堆空间动态申请的；

2.局部变量所在的栈。

野指针不是NULL指针，是指向不可用内存的指针，也可能是一个动态的内存地址，但是这个内存别人正在使用，这也是不合法的地址。

NULL指针不容易用错，因为if语句很好判断一个指针是不是NULL。C语言中没有任何手段可以判断一个指针是否为野指针！

 

野指针的由来

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

#include <stdio.h>

#include <string.h>

 

struct Student

{

    char* name;

    int number;

};

 

int main()

{

    struct Student s;

    

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

    

    s.number = 99;

    

    

    return 0;

}

局部变量没有被初始化，指针name指向的内存空间地址是随机的，当然不能向随机地址空间写数据。

2.使用已经释放过后的指针；

#include <stdio.h>

#include <malloc.h>

#include <string.h>

 

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!使用已经释放的指针s

    

    return 0;

}

释放一片指针后，意味着把这片内存归还到空闲链表，归还意味着其它程序可以使用这片空间，

如果写了其它程序使用的空间，可能导致其它程序莫名其妙的被关闭。

3.指针所指向的变量在指针之前被销毁。

#include <stdio.h>

 

char* func()

{

    char p[] = "Delphi Tang";

    

    return p;

}

 

int main()

{

    char* s = func();

    

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

    

    return 0;

}

函数调用的时候，在栈区存放局部变量，p是局部数组，放在活动记录里面，func返回之后，

栈顶指针退出，活动记录占用内存已经被释放掉，s指向一个被释放掉了栈空间，如果栈空间值被修改了，

就不会打印出预期结果，s是个野指针。

 

非法内存操作分析

1.结构体成员指针未初始化

2.没有为结构体指针分配足够的内存

#include <stdio.h>

#include <malloc.h>

 

struct Demo

{

    int* p;

};

 

int main()

{

    struct Demo d1;

    struct Demo d2;

    

    int i = 0;

    

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

    {

        d1.p[i] = 0; // OOPS!结构体指针未初始化

    }

    

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

    

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

    {

        d2.p[i] = i; // OOPS!数组越界

    }

    

    free(d2.p);

    

    return 0;

}

 

3.内存初始化分析

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

int main(void)

{

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

    printf(s);//没有在内存中填充数据，就相当然作为字符串来使用，是不是字符串还不一定

    free(s);

    return 0;

}

以上程序只需改写一个字母就会绝对正确。

 

4.内存越界分析

数组越界

#include <stdio.h>

 

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.内存泄露

#include <stdio.h>

#include <malloc.h>

 

void f(unsigned int size)

{

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

    int i = 0;

    

    if( size % 2 != 0 )

    {

        return; // OOPS!出口1，还没有释放内存就结束

    }

    

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

    {

        p[i] = i;

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

    }

    

    free(p);//出口2

}

//f函数有一个入口，两个出口，最好“单入口，单出口”

int main()

{

    f(9);

    f(10);

       

    return 0;

}

修改后“单入口，单出口”

#include <stdio.h>

#include <malloc.h>

 

void f(unsigned int size)

{

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

    int i = 0;

    

    if( size % 2 == 0 )

    {

        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.多次释放指针

会导致异常退出

#include <stdio.h>

#include <malloc.h>

 

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;

}

 

解决方法：谁申请谁释放，在main中申请就在main中释放。

以上程序也可以采取这样的解决方法,在f函数中增加第三个参数，然后在main中决定是否释放

#include <stdio.h>

#include <malloc.h>

 

void f(int* p, int size，int toFree)

{

    int i = 0;

    

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

    {

        p[i] = i;

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

    }

    if(toFree)

    {

        free(p);//释放

    }

}

 

int main()

{

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

    

    f(p, 5,0);

    

    free(p); // OOPS!二次释放

       

    return 0;

}

7.使用已释放的指针

#include <stdio.h>

#include <malloc.h>

 

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);//在函数f中已经释放p指向的内存

    

    for(i=0; i<5; i++)//而又在此处操作p所指向的内存，p是野指针。

    {

        p[i] = i; // OOPS!

    }

       

    return 0;

}

 

 

C语言中的交通规则（我们自己约定的规则，可以避免错误）

1.用malloc申请了内存之后，应该立即检查指针值是否为NULL，防止使用值为NULL的指针;

这样可以杜绝操作0内存地址的内容，0内存地址是非常特殊的地址，是操作系统所使用的。

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

if( p != NULL )

{

//do something here!

}

free(p);

 

2.牢记数组的长度，防止数组越界操作，考虑使用柔性数组;

typedef struct _soft_array

{

    int len;

    int array[];

}SoftArray;

 

int i = 0;

SoftArray *sa = (SoftArray*)malloc(sizeof(SoftArray) + sizeof(int)*10);

 

sa->len = 10;

 

for(i=0; i<sa->len; i++)

{

    sa->array[i] = i+1;

}

 

3.动态申请的操作必须和释放操作匹配，防止内存泄露和多次释放

void f()

{

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

    free(p);

}

 

int main()

{

int *p = (int*)malloc(10);

f();

free(p);;

return 0;

}

 

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

int *p = (int*)malloc(10);

free(p);

p = NULL;

//...

//......

//.........

if(p != NULL)

{

    int i = 0;

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

    {

        p[i] = i;

    }

}