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释放内存。动态内存的生存期由我们决定，使用非常灵活。