C/C++内存管理

1.相关链接

1. http://club.topsage.com/thread-443540-1-1.html

2.http://www.cnblogs.com/lancidie/archive/2011/08/05/2128318.html

2.栈内存，堆内存

     如果函数的参数是一个指针，不要指望用该指针去申请动态内存。示例7-4-1中，Test函数的语句GetMemory(str, 200)并没有使str获得期望的内存，str依旧是NULL，为什么？

1. void GetMemory(char *p, int num)
   
2. {
   
3. 　p = (char *)malloc(sizeof(char) * num);
   
4. }
   
5. void Test(void)
   
6. {
   
7. 　char *str = NULL;
   
8. 　GetMemory(str, 100); // str 仍然为 NULL
   
9. 　strcpy(str, "hello"); // 运行错误
   
10. }

复制代码

示例4.1 试图用指针参数申请动态内存

　　毛病出在函数GetMemory中。编译器总是要为函数的每个参数制作临时副本，指针参数p的副本是 _p，编译器使 _p = p。如果函数体内的程序修改了_p的内容，就导致参数p的内容作相应的修改。这就是指针可以用作输出参数的原因。在本例中，_p申请了新的内存，只是把 _p所指的内存地址改变了，但是p丝毫未变。所以函数GetMemory并不能输出任何东西。事实上，每执行一次GetMemory就会泄露一块内存，因为没有用free释放内存。

　　如果非得要用指针参数去申请内存，那么应该改用“指向指针的指针”，见示例4.2。

1. void GetMemory2(char **p, int num)
   
2. {
   
3. 　*p = (char *)malloc(sizeof(char) * num);
   
4. }
   
5. void Test2(void)
   
6. {
   
7. 　char *str = NULL;
   
8. 　GetMemory2(&str, 100); // 注意参数是 &str，而不是str
   
9. 　strcpy(str, "hello");
   
10. 　cout<< str << endl;
    
11. 　free(str);
    
12. }

复制代码

示例4.2用指向指针的指针申请动态内存

　　由于“指向指针的指针”这个概念不容易理解，我们可以用函数返回值来传递动态内存。这种方法更加简单，见示例4.3。

1. char *GetMemory3(int num)
   
2. {
   
3. 　char *p = (char *)malloc(sizeof(char) * num);
   
4. 　return p;
   
5. }
   
6. void Test3(void)
   
7. {
   
8. 　char *str = NULL;
   
9. 　str = GetMemory3(100);
   
10. 　strcpy(str, "hello");
    
11. 　cout<< str << endl;
    
12. 　free(str);
    
13. }

复制代码

示例4.3 用函数返回值来传递动态内存

　　用函数返回值来传递动态内存这种方法虽然好用，但是常常有人把return语句用错了。这里强调不要用return语句返回指向“栈内存”的指针，因为该内存在函数结束时自动消亡。见示例4.4。

1. char *GetString(void)
   
2. {
   
3. 　char p[] = "hello world";
   
4. 　return p; // 编译器将提出警告
   
5. }
   
6. void Test4(void)
   
7. {
   
8. 　char *str = NULL;
   
9. 　str = GetString(); // str 的内容是垃圾
   
10. 　cout<< str << endl;
    
11. }

复制代码

示例4.4 return语句返回指向“栈内存”的指针

补充内容：

#include "stdafx.h"
#include <stdio.h>
int * getValue()
{
  int abb = 111;
  return &abb;
}   
int main(int argc, char* argv[])
{
  int xx= (*getValue());
  int a =2,b=3,c=4,d=5,e=4,f=5,g=5;  
  printf("[%d]\n",xx);
return 0;
}




执行结果：[111]
//你的那个放在一起了...由在那个表达式中,要区分的话很难.
//用C++可以很好给你区分出来
#include <stdio.h> 
int * getValue() 
{ 
    int abb = 111; 
    return &abb; 
}          
void fuck()
{
    int xx = 123;
}
int main(int argc, char* argv[]) 
{ 
    int xx= 0;
    int* p = getValue();
    fuck(); 
    xx = *p;
    int a =2,b=3,c=4,d=5,e=4,f=5,g=5; 
    printf("[%d]\n",xx); 
return 0; 
} 

 

执行结构：
[123]

简言之，就是虽然那个局部变量占用的内存标记为释放了，但是这个地方的治并没有改变，因此你通过指向这个地址的指针进行访问的时候，就会产生局部变量还在的假象。
主调函数栈底用MS表示,忽略其它信息.在进入main时栈为空.遇到xx的时候,分配一段空间,记为MSxx的空间要调用getValue于是再分配一段空间,作为函数调用的...也就是说MSxx的空间一些填充信息的空间函数调用的信息在getValue中定义变量abb后如下MSxx的空间一些填充信息的空间函数调用的信息abb=111好,现在程序返回把abb的地址返回了.栈如下MSxx的空间{一些填充信息的空间函数调用的信息abb}{}内表示这一段没有用了,但是信息还在现在取abb所在的内存的值.OK,得到111.放进xxMSxx
 = 111{一些填充信息的空间函数调用的信息abb}可以看出来,虽然没有用,但是值还在...我在这个中间过程中加一个函数调用...于是就crack掉.总之,对于{}的内容不要报任何侥幸心理.编译器完全可以在函数结束的时候...把{}上的内容设置为其它值...这样就可以防止你产生这种错误观点了...
 
#include <stdio.h> 
int getValue() 
{ 
    int abb = 111; 
    return abb; 
}          
void fuck()
{
    int xx = 123;
}
int main(int argc, char* argv[]) 
{ 
    int xx= 0;
    int  p = getValue();
    fuck(); 
    xx = p;
    int a =2,b=3,c=4,d=5,e=4,f=5,g=5; 
    printf("[%d]\n",xx); 
return 0; 
} 


执行结构：
[111]
3.关于常量字符串常量指针
http://www.newsmth.net/pc/pccon.php?id=10003130&nid=376936