指针做为参数传递

如果一个函数的参数是一个指针，不能用此指针去动态申请内存，

#include <iostream>
#include <stdio.h>
using namespace std;

void GetMemory(char *p,int size)
{
    p = (char*)malloc(sizeof(char)*size);   //申请内存空间
}
void Test()
{
    char *str = NULL;
    GetMemory(str，100); //str 任然是NULL
    strcpy(str,"hello");  //运行报错
}
int main(void)
{
    Test();

    return 0;
}

      发送错误是因为：GetMemory()函数中申请内存的时候，函数为参数申请了一个临时副本：_p=p,如果函数体内修改了副本的内容，那么也就修改了P的内容，这就符合了指针作为输出参数的原因，但是在这里，只是把副本_p的内存地址改变了，但是P没有被改变，所以不能返回。

      解决办法就是使用“指向指针的指针”去申请内存。实例代码如下：

void GetMemory(char **p,int size)
{
    *p = (char*)malloc(sizeof(char)*size);   //申请内存空间
}
void Test()
{
    char *str = NULL;
    int n = 10;
    GetMemory(&str, n);
    strcpy(str,"hello");  
    cout<<str<<endl;
    free(str);
}

还可以使用返回指针的形式：

char* GetMemory(int size)
{
	char *p = (char*)malloc(sizeof(char)*size);   //申请内存空间
	return p;
}
void Test()
{
	char *str = NULL;
	int n = 10;
	str = GetMemory(n); 
	strcpy(str,"hello");  
	cout<<str<<endl;
	free(str);
}

不要出现下面的情况：编译器报错，p只有在GetMemory()函数中有效，返回后p指向的对象的值被销毁，所以此时指向的值是乱码。

char* GetMemory(int size)
{
	char *p[] = "hello world";
	return p;
}
void Test()
{
	char *str = NULL;
	int n = 10;
	str = GetMemory(n);   
	cout<<str<<endl;
	free(str);
}

下面这种设计方法，编译的时候不会报错，但是这种设计方式是不对的，因为char* p= “hello world”，申请了一个字符串常量，它存储在静态数据区，在程序的整个生命周期中，无论什么时候访问，都可以得到hello world的值。

char* GetMemory(int size)
{
    char *p = "hello world";
    return p;
}
void Test()
{
    char *str = NULL;
    int n = 10;
    str = GetMemory(n);  
    cout<<str<<endl;
    free(str);
}

函数参数的默认值只能出现在申明中，不能在定义体中出现，而且顺序只能是从右到左，有时候还会出现二义性。

示例：

void func(int a,int b=10)；//申明的时候
void func(int a =10, int b, int c = 2);//报错，顺序只能从右到左
void func(int a, int b =10)   //报错
{
   
}