指针作为函数形参的思考

原文链接
最近在论坛上看到有一篇帖子提问下面的问题：

char * fun(char *p)
{
return p;
}
提问：此函数返回的是谁的值，是参数p的地址，还是p的值？

回答：

p的值，但其值指向一个内存地址

p是栈中的地址，和局部变量的地址一样，函数返回后这块内存就无效了。

这种用法还是很常见的，比如链表中。

虽然p是栈中的地址，但是因为它只是指针副本，所以可以改变指针的指向(通过return的返回值)，指向其他地方。

记得在学习C语言函数那部分的时候，有一个很重要的概念是区别：值传递、指针传递、引用传递(好像是这三种说法)。

我觉得要理解这部分知识点，首先应该知道不同种类的变量在内存中是如何分配存储的，它们的生命周期多长等这些问题，然后再看上面的三种情况就好理解了。函数的参数都是在stack栈上分配的，所以它们的生命周期就在它们所属的函数内，函数执行完毕的时候，它们所占的内存将被回收。

如果我们想在函数内对实参进行操作(不是对实参的副本，形参)的话，一般会使用引用，即声明函数的形参为引用类型，比如char * fun(char * &p)，这样实参和形参为同一个变量，我们在函数中操作形参p就等于直接在操作实参变量。在看C++语法书的时候，书上说这样用还有一个好处是，在调用函数的时候，不用再为形参分配内存了，所以这样执行效率会高一点儿。

下面是函数形参为指针的几种情况：

#include <iostream>
using namespace std;
char* func1(char *p);
void func2(char *p);
void func3(char * &p);
char s1[]="原来的";
char s2[]="指向我了吗";
int main()
{
    char *ptr=s1;
    cout<<ptr<<endl;
    ptr=func1(ptr);     //返回值改变ptr使它指向另一个地址
    //func2(ptr);       //ptr的指向没有改变，func2函数中改变的只是它的副本(一个局部变量)
    //func3(ptr);       //改变了ptr的指向，func3函数的形式参数为引用类型，实参和形参是同一个变量
    cout<<ptr<<endl;
    return 0;
}
char* func1(char *p)
{
    p=s2;
    return p;
}
void func2(char *p)
{
    p=s2;
}
void func3(char * &p)
{
    p=s2;
}

下面再看一个在实际应用中经常会出错的一个例子(检测一下我们是否理解了上面的概念)：

#include <malloc.h>
struct stack 
{ 
    char *elem[10]; 
    int top; 
}; 
void initial1(struct stack *s)//值传递
{
    s = (stack*)malloc(sizeof(stack));
}
void initial2(struct stack **s)//指针传递
{
    *s = (stack*)malloc(sizeof(stack));
}
void initial3(struct stack *&s)//引用传递
{
    s = (stack*)malloc(sizeof(stack));
}
int main(int argc, char* argv[])
{
    struct stack *s;
    //initial1(s); // error，没有获得返回的值
    initial2(&s);  // ok
    initial3(s);   // ok
    
    return 0;
}

下面是某company对此知识点出的考题：

[Q1]
void Getmemory(char*p) 
{ 
    p=(char*)malloc(100); 
} 
void Test(void) 
{ 
    char *str=NULL; 
    Getmemory(str); 
    strcpy(str,"Hello world"); 
    printf(str); 
}
//modified to:
#include <stdio.h>
#include <string>
void Getmemory(char**p) 
{ 
    *p=(char*)malloc(100*sizeof(char)); 
} 
void Test() 
{ 
    char *str=NULL; 
    Getmemory(&str); 
    strcpy(str,"Hello world"); 
    printf(str);
}
int main()
{
    Test();
    return 0;
}

[Q2] 
char* Getmemory(void) 
{ 
    char p[]="hello world"; 
    return p; 
} 
void Test(void) 
{ 
    char *str=NULL; 
    str=Getmemory(); 
    printf(str); 
} 
//modified to:
#include <stdio.h>
char* Getmemory(void) 
{ 
    char p[]="hello world"; 
    return p; //returning address of local variable or temporary
} 
void Test() 
{ 
    char *str=NULL; 
    str=Getmemory(); 
    printf(str); //unknown results
}
int main()
{
    Test();
    return 0;
}

[Q3] 
void Getmemory(char**p,int num) 
{ 
    *p=(char*)malloc(num); 
}
void Test(void) 
{ 
    char *str=NULL; 
    Getmemory(&str,100); 
    strcpy(str,"Hello world"); 
    printf(str); 
}
//modified to:
#include <stdio.h>
#include <string>
void Getmemory(char**p,int num) 
{ 
    *p=(char*)malloc(num*sizeof(char)); 
} 
void Test() 
{ 
    char *str=NULL; 
    Getmemory(&str,100); 
    strcpy(str,"Hello world"); 
    printf(str); //print "Hello world" 
}
int main()
{
    Test();
    return 0;
}
 
[Q4]
void Test(void) 
{ 
    char *str=(char*)malloc(100); 
    strcpy(str,"Hello"); 
    free(str); 
    if(str!=NULL) 
        strcpy(str,"world"); 
    printf(str); 
} 
//modified to:
#include <stdio.h>
#include <string>
void Test() 
{ 
    char *str=(char*)malloc(100*sizeof(char)); 
    strcpy(str,"Hello"); 
    free(str); // free the contents which str points
        //in this place, we'd better set str to NULL otherwise the pointer str will to be a wild pointer
    if(str!=NULL) //this statement is always true,for str is non-NULL
        strcpy(str,"world"); 
    printf(str); //print "world"
} 
int main()
{
    Test();
    return 0;
}