c++动态内存传递

最近在看程序员面试宝典的书中遇到了传递动态内存的问题。

#include <iostream>using namespace std;void GetMemory(char *p,int num){    p=(char *)malloc(sizeof(char) * num);}void Test(void){    char *str=NULL;    GetMemory(str,100);    //str仍然为NULL    strcpy(str,"hello");//运行错误}int main(){    Test();    return 0;}

书上的解释是：在函数GetMemory(char *p,int num)中，*p实际上是主函数中str的一个副本，p申请了内存，只是把p指向的内存地址改变，而str并没有改变，所以str依然没有获得内存，在执行字符串复制时就会出错。而且每次p申请的内存都不会得到释放，最终会造成内存泄露。

不胜理解，查找相关资料发现是值传递和地址传递的问题。

在C语言中函数参数的传递有：值传递，地址传递，引用传递这三种形式。

1、值传递：形参是实参的拷贝，改变形参的值并不会影响外部实参的值。从被调用函数的角度来说，值传递是单向的（实参->形参），参数的值只能传入，不能传出。当函数内部需要修改参数，并且不希望这个改变影响调用者时，采用值传递。

典型代码：

#include <iostream>using namespace std;void swap(int p,int q){    int temp;    temp=p;    p=q;    q=temp;    //cout<<p<<""<<q<<endl;}int main(){    int a=1,b=3;    swap(a,b);    cout<<a<<endl;    cout<<b<<endl;     return 0;}

最后输出的结果a=1,b=3；可以看到a、b的值并没有改变，实参a、b在传递参数给形参p、q的时候，本身并不会改变，最后形参的值不会再重新传回给实参，改变的是形参p、q的值，实参a、b不会发生任何改变。注意在函数调用的时候，参数的值传递只是将实参a、b的值传递给p、q，并不是用a、b取代形参p、q进行操作（这就是我们理解的误区）。

2、地址传递：形参为指向实参地址的指针，当对形参的指向操作时，就相当于对实参本身进行的操作。

#include <iostream>using namespace std;void swap(int *p,int *q){    int temp;    temp=*p;    *p=*q;    *q=temp;    //cout<<p<<""<<q<<endl;}int main(){    int a=1,b=3;    swap(&a,&b);    cout<<a<<endl;    cout<<b<<endl;     return 0;}

最后输出的结果a=3,b=1；达到了a、b交换的效果。函数swap(int *p,int *q)中形参p、q均为指针，在函数引用的时候：swap(&a,&b);即相当于p=&a；q=&b；将a、b的地址赋值给了p、q，自然指针p指向了a，q指向了b，对*p，*q进行操作自然也就是对a、b的操作了，所以最后a、b的值进行了交换。这就是地址传递（将a、b的地址传递给形参）。

3、引用传递：形参相当于是实参的“别名”，对形参的操作其实就是对实参的操作，在引用传递过程中，被调函数的形式参数虽然也作为局部变量在栈中开辟了内存空间，但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址，即通过栈中存放的地址访问主调函数中的实参变量。正因为如此，被调函数对形参做的任何操作都影响了主调函数中的实参变量。

#include <iostream>using namespace std;void swap(int &p,int &q)//注意定义处的形式参数的格式与值传递不同{    int temp;    temp=p;    p=q;    q=temp;    //cout<<p<<""<<q<<endl;}int main(){    int a=1,b=3;    swap(a,b);    cout<<a<<endl;    cout<<b<<endl;     return 0;}

最后输出的结果a=3,b=1；达到了a、b交换的效果。

　　此时我们要注意与值传递的区别，函数定义的时候swap(int &p, int &q)；其中标注了形参为引用，在调用函数swap(a,b)的时候进行参数传递，此时相当于&p=a；q=&b；即p为a的引用，q为b的引用，此时p、q就相当于a、b的别名，对p、q的操作也就是直接对a、b的操作。

　　回到最上面的代码处，在调用函数GetMemory(str,100)的时候，str为指针，存储的为地址，进行参数传递的时候将str的地址传递给指针p，最开始指针p指向NULL，使用malloc开辟新的内存后，p就指向了新开辟的内存空间，但是实参str并没有改变，还是指向了NULL，p指向新开辟的内存空间后也没有释放，如此就造成了内存泄露，导致错误。

　　对于修改方法有三种修改方法。

1、使用引用。

#include <iostream>#include <malloc.h>#include <string.h>using namespace std;void GetMemory(char *&p,int num){    p=(char *)malloc(sizeof(char) * num);}void Test(void){    char *str=NULL;    GetMemory(str,100);    strcpy(str,"hello");//     cout<<str<<endl;}int main(){    Test();    return 0;}

输出结果为hello，符合预期期望。在函数定义时GetMemory(char* &p,int num),将指针p定义为引用，在参数传递的时候&p=str，即p为指针str的别名，对指针p的操作也就是对str的操作，所以指针str也会指向新开辟的内存空间。

2、使用函数返回值。

#include <iostream>#include <malloc.h>#include <string.h>using namespace std;char *GetMemory(char *p,int num){    p=(char *)malloc(sizeof(char) * num);    return p;}void Test(void){    char *str=NULL;    str=GetMemory(str,100);    strcpy(str,"hello");    //cout<<&str<<endl;     cout<<str<<endl;}int main(){    Test();    return 0;}

输出结果为hello，符合预期期望。调用函数GetMemory(str,100);的时候返回的是指针p，再将str=GetMemory(str,100);进行赋值，相当于str=p，即str也指向了新开辟的内存单元，不再指向NULL，可以对其进行操作，最后输出我们所需要的结果。

3、使用二级指针即指向指针的指针。

#include <iostream>#include <malloc.h>#include <string.h>using namespace std;void GetMemory(char **p,int num){    *p=(char *)malloc(sizeof(char) * num);}void Test(void){    char *str=NULL;    GetMemory(&str,100);    strcpy(str,"hello");    //cout<<&str<<endl;     cout<<str<<endl;}int main(){    Test();    return 0;}

输出结果为hello，符合预期期望。函数定义中GetMemory(char **p,int num)，p为二级指针，在函数调用GetMemory(&str,100)进行值传递的时候，此时相当于地址传递，指针*p=&str，*p存储的是指针str的地址，我们通过修改*p即是修改了str的地址，将*p指向新开辟的内存空间即是将str的地址指向了新开辟的内存空间，进而str也就指向了新开辟的内存空间，从而达到了动态内存传递的效果。

char *str=NULL；栈中操作的时候，内存为内存为0x28ff2c的地址存储内容为NULL

内存分配方式有三种：

• 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。
• 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
• 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定，使用非常灵活。