C 语言内存分配

1 什么是野指针

   前面我们把内存比作尺子，很轻松的理解了内存。尺子上的 0 毫米处就是内存的0 地址处，也就是 NULL 地址处。这条栓“野指针”的链子就是这个“NULL”。定义指针变量的同时最好初始化为 NULL，用完指针之后也将指针变量的值设置为 NULL。也就是说除了在使用时，别的时间都把指针“栓”到 0 地址处。这样它就老实了。

2 栈、堆和静态区

   静态区：保存自动全局变量和 static变量（包括 static全局和局部变量）。静态区的内容
在总个程序的生命周期内都存在，由编译器在编译的时候分配。

   栈：保存局部变量。栈上的内容只在函数的范围内存在，当函数运行结束，这些内容也会自动被销毁。其特点是效率高，但空间大小有限。

   堆：由 malloc系列函数或 new操作符分配的内存。其生命周期由 free或 delete决定。在没有释放之前一直存在，直到程序结束。其特点是使用灵活，空间比较大，但容易出错。

3 常见的内存错误及对策

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

  1.1 结构体成员指针未初始化

struct student
{
   char *name;
   int score;
}stu,*pstu;
int main()
{
   strcpy(stu.name,"Jimy");
   stu.score = 99;
   return 0;
}

  注意：strcpy原型

 char *strcpy(char *strDest, const char *strSrc);//第二个参数设置为常量 是不想在函数中间 让其发生改变
{
    assert((strDest!=NULL) && (strSrc !=NULL)); // 这句是断言 判断不该出现的错误
//如果出现作物 立即在这里停止
    char *address = strDest;//创建一个地址指针用于返回     
    while( (*strDest++ = * strSrc++) != ‘\0’ )  // 2分
       //这句比较复杂 
//(*strDest++ = * strSrc++) 这个是逐位赋值
而每次赋值之后 用*strDest！='/0'进行比较作为循环条件结束 也就是 strSrc已经复制到结束了
    return address ;//最后返回      
}

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

   为指针变量 pstu分配了内存，但是同样没有给name指针分配内存。错误与上面第一种情况一样，解决的办法也一样。这里用了一个 malloc给人一种错觉，以为也给 name 指针分配了内存。

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

   int main()
{
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 指针同样没有被分配内存。解决办法同上。

    1.3 函数的入口校验

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

   2）为指针分配的内存太小

   为指针分配了内存，但是内存大小不够，导致出现越界错误。
   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）这种写法。这样只会使你的代码可移植性下降。

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

 在定义一个变量时，第一件事就是初始化。你可以把它初始化为一个有效的值，比如:
    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)）;

    4）内存越界

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

   5）内存泄漏

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

    1.下面先看 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）语句来验证内存确实分配成功了。

    2. 内存释放

    既然有分配，那就必须有释放。不然的话，有限的内存总会用光，而没有释放的内存
却在空闲。与 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次数弄错了。

   3. 内存释放之后

   既然使用 free函数之后指针变量p 本身保存的地址并没有改变， 那我们就需要重新把p
的值变为 NULL：
   p = NULL;
   这个 NULL 就是我们前面所说的“栓野狗的链子” 。如果你不栓起来迟早会出问题的。比如：
在 free（p）之后，你用 if（NULL ！=p）这样的校验语句还能起作用吗？

   例如：
char *p = (char *)malloc(100);
strcpy(p, “hello”);
free(p);
⋯
if (NULL != p)
{

strcpy(p, “world”);
}
    释放完块内存之后，没有把指针置 NULL，这个指针就成为了“野指针” ，也有书叫“悬垂指针” 。这是很危险的，而且也是经常出错的地方。所以一定要记住一条：free完之后，一定要给指针置 NULL。

   4. 内存已经被释放了，但是继续通过指针来使用

   这里一般有三种情况：
   第一种：就是上面所说的，free（p）之后，继续通过 p 指针来访问内存。解决的办法
就是给 p 置NULL。
   第二种：函数返回栈内存。这是初学者最容易犯的错误。比如在函数内部定义了一个数组， 却用 return语句返回指向该数组的指针。 解决的办法就是弄明白栈上变量的生命周期。

   第三种：内存使用太复杂，弄不清到底哪块内存被释放，哪块没有被释放。解决的办法是重新设计程序，改善对象之间的调用关系。