浅谈C语言函数返回值--局部变量和局部变量地址

下面的内容是在C专家编程里面看到的，摘录于此。

在C语言中，局部变量的作用域只在函数内部，在函数返回后，局部变量的内存就会被释放。如果函数只是返回局部变量，那么这个局部变量会被复制一份传回被调用处。但是如果函数返回的是局部变量的地址，那么就会报错，因为函数只是把指针复制后返回了，但是指针指向的内容已经被释放，这样指针指向的内容就是不可预料的内容，程序就会出错。准确的来说，函数不能通过返回指向栈内存的指针（返回指向堆内存的指针是可以的）。

先来看一个函数返回局部变量的例子

1.  
   #include <stdio.h>
2.  
    
3.  
   int fun()
4.  
   {
5.  
   int num = 100;
6.  
   num = num + 100;
7.  
    
8.  
   return num;
9.  
   }
10.  
    int main()
11.  
    {
12.  
    int num;
13.  
     
14.  
    num = fun();
15.  
     
16.  
    printf("%d ", num);
17.  
     
18.  
    return 0;
19.  
    }

fun函数返回一个int的局部变量，函数会把局部的num的值复制一份拷贝给主函数里面的num。这样是可以的，而且这种方式在程序里面还是经常用到的。上面程序输出：200

下面函数返回局部变量地址

1.  
   #include <stdio.h>
2.  
    
3.  
   char *fun()
4.  
   {
5.  
   char buffer[20];
6.  
   int i;
7.  
   for(i = 0; i < sizeof(buffer)-1; i++)
8.  
   buffer[i] = 'a';
9.  
   buffer[i] = '';
10.  
    return buffer;
11.  
    }
12.  
    int main()
13.  
    {
14.  
    char *str;
15.  
    str = fun();
16.  
    printf("%s ", str);
17.  
    return 0;
18.  
    }

编译运行：

编译警告程序返回局部变量地址，输出为乱码。因为fun返回的是局部变量的地址，真是拷贝了一份地址，地址所指向的内容在fun结束的时候已经释放，变量已经被销毁，现在根本不知道地址指向的内容的是什么。

如果确实要返回一个局部变量的地址应该怎么做，解决这个问题有下面几种方案。

1、返回一个字符串常量的指针

1.  
   #include <stdio.h>
2.  
    
3.  
   char *fun()
4.  
   {
5.  
   char *buffer = "aaaaaaaaaa";
6.  
   return buffer;
7.  
   }
8.  
   int main()
9.  
   {
10.  
    char *str;
11.  
    str = fun();
12.  
    printf("%s ", str);
13.  
    return 0;
14.  
    }

编译运行

这样程序运行是没有问题的，buffer存在只读内存区，在fun退出的时候，字符串常量不会被收回，因此把地址赋给str时可以正确访问。上面这个方式只是最简单的解决方案，因为字符串存放在只读内存区，以后需要修改它的时候就会很麻烦。

2、使用全局声明的数组。

1.  
   #include <stdio.h>
2.  
    
3.  
   char buffer[20];
4.  
    
5.  
   char *fun()
6.  
   {
7.  
   int i;
8.  
   for(i = 0; i < sizeof(buffer)-1; i++)
9.  
   buffer[i] = 'a'+ i;
10.  
    buffer[i] = '';
11.  
    return buffer;
12.  
    }
13.  
    int main()
14.  
    {
15.  
    char *str;
16.  
    str = fun();
17.  
    printf("%s ", str);
18.  
    return 0;
19.  
    }

编译运行

这种情况适用于自己创建字符串，而且简单容易。缺点就是任何人都有可能在任何时候修改这个全局数组，而且该函数的下一次调用会覆盖数组的内容。

3、使用静态数组

1.  
   #include <stdio.h>
2.  
    
3.  
   char *fun()
4.  
   {
5.  
   int i;
6.  
   static char buffer[20];
7.  
   for(i = 0; i < sizeof(buffer)-1; i++)
8.  
   buffer[i] = 'a'+ i;
9.  
   buffer[i] = '';
10.  
    return buffer;
11.  
    }
12.  
    int main()
13.  
    {
14.  
    char *str;
15.  
    str = fun();
16.  
    printf("%s ", str);
17.  
    return 0;
18.  
    }

编译运行

使用静态数组可以保证内存不被回收，而且可以防止任何人修改这个数组。只有拥有指向该数组的指针的函数才能修改这个静态数组，不过同时该函数的下一次调用会覆盖数组的内容。同时和全局数组一样，大型缓冲区闲置是非常浪费空间的。

4、显示的分配内存，在堆上动态分配内存。

1.  
   #include <stdio.h>
2.  
   #include <stdlib.h>
3.  
   #include <string.h>
4.  
   char *fun()
5.  
   {
6.  
   int i;
7.  
   char *buffer = (char *)malloc(sizeof(char) * 20);
8.  
   strcpy(buffer, "abcdefg");
9.  
   return buffer;
10.  
    }
11.  
    int main()
12.  
    {
13.  
    char *str;
14.  
    str = fun();
15.  
    printf("%s ", str);
16.  
    return 0;
17.  
    }

这个方法具有静态数组的方法，而且每次调用都创建一个新的缓冲区，不会覆盖以前的内容。适用于多线程代码。缺点是程序员必须承担内存的管理，这项任务可能很复杂，很容易产生内存泄露或者尚在使用就被释放。

5、最好的解决办法就是调用者分配内存来保存函数的返回值，同时指定缓冲区的大小

1.  
   #include <stdio.h>
2.  
   #include <stdlib.h>
3.  
   #include <string.h>
4.  
   void fun(char *str, int size)
5.  
   {
6.  
   char *s = "abcdefghijklmnopq";
7.  
   strncpy(str, s, size);
8.  
   }
9.  
   int main()
10.  
    {
11.  
    int size = 10;
12.  
    char *str = (char *)malloc(sizeof(char) * size);
13.  
    fun(str, size);
14.  
    printf("%s ", str);
15.  
    free(str);
16.  
    return 0;
17.  
    }

编译运行

程序员在同一块代码中同时进行malloc和free操作，内存管理最安全，方便。