为什么返回值为数值时,返回局部变量可以。而返回值为引用时,不能返回局部变量

 

 

 

 

 

 

 

最重要的一点:函数不能返回指向栈内存的指针!

https://blog.csdn.net/weixin_40539125/article/details/81367466

为什么?因为返回的都是值拷贝!

        一般的来说,函数是可以返回局部变量的。 局部变量的作用域只在函数内部,在函数返回后,局部变量的内存已经释放了。因此,如果函数返回的是局部变量的值,不涉及地址,程序不会出错。但是如果返回的是局部变量的地址(指针)的话,程序运行后会出错。因为函数只是把指针复制后返回了,但是指针指向的内容已经被释放了,这样指针指向的内容就是不可预料的内容,调用就会出错。准确的来说,函数不能通过返回指向栈内存的指针(注意这里指的是栈,返回指向堆内存的指针是可以的)。

       我们知道,局部变量的作用域是函数内部,函数一旦执行结束,栈上的局部变量会进行销毁,内存得到释放。因此,此时函数返回的是该局部变量的值拷贝,这是没有问题的。但是如果返回的是局部变量的地址,那么返回的只是该局部变量指针的拷贝,而随着函数运行结束,该拷贝指针所指向的栈内存已经被释放,那么指向一个未知区域就会导致调用的错误。

      那如果返回的指针指向的是堆内存,又会怎么样?

      这样的使用是没有问题的,在函数内new空间,在函数外delete空间。但是这样并不是一种好的编程风格,尽量在同一个作用域内进行new和delete操作,否则还要调用者手动进行内存的释放,试问这样的接口是不是很烂。如果确实需要这样做,那就传指针进去吧!

 
  1. #include "fun_stdy.h"

  2. #include <iostream>

  3. using namespace std;

  4.  
  5. int return_value0(){

  6. int ret = 0;

  7. cout << " in return_value0 , address and value:"<< &ret <<" "<< ret <<endl;

  8.  
  9. return ret; //ok 最常见的情况, 返回局部变量的副本

  10. }

  11.  
  12. int* return_value1()

  13. {

  14. int ret=1;

  15. cout << " in return_value1 , and value:"<< &ret<<" " << ret <<endl;

  16.  
  17. return &ret; //error 虽然value被释放 , 但里面的值可能不会被清除,所以有时候你这么用

  18. //看起来结果好像也是对的,但是隐患无穷。

  19. }

  20.  
  21. int* return_value2()

  22. {

  23. int *ret = new int(2);

  24. cout << " in return_value2 , address and value:"<< &ret <<" " << ret <<endl;

  25.  
  26. return ret; //ok 在函数内申请空间,调用后需要调用者手动在函数外释放空间

  27. }

  28. int* return_value3(int *ret) //指针value不能为null,否则报错

  29. {

  30. ret = new int(3);

  31. cout << " in return_value3 , address and value:"<< &ret<<" " << ret <<endl;

  32.  
  33. return ret; //ok 在函数内申请空间,调用后需要调用者手动在函数外释放空间

  34. }

  35.  
  36. char *return_value4()

  37. {

  38. char p[] = "hello world";

  39. cout << " in return_value4 , address and value:"<< &p<<" " << p <<endl;

  40.  
  41. return p; //p[]数组为函数内部局部变量,在函数返回后,内存已经被释放了,

  42. //所以在主函数中调用该函数str2 = return_value3();输出的可能为乱码

  43. }

  44.  
  45. //此函数中p也是个局部变量,函数执行完自动销毁,但是指针分配的空间不会被自动回收,除非程序员delete掉。

  46. //所以这个可以正常输出。

  47. char *return_value5()

  48. {

  49. char *p = "hello world";//这个初始化的一种形式,相当于分配了sizeof(hello world)个空间

  50. cout << " in return_value5 , address and value:"<< &p <<" "<< p << endl;

  51.  
  52. return p;

  53. }

  54.  
  55. /* 如果真要返回局部变量的引用和指针 ,请用static */

  56.  
  57. char *return_value6()

  58. {

  59. static char p[] = "hello world";

  60. cout << " in return_value6 , static_pointer's address and value:"<< &p <<" "<< p << endl;

  61.  
  62. return p;

  63. }

 
  1.  
  2. #include <iostream>

  3. #include "fun_stdy.h"

  4. using namespace std;

  5.  
  6. int main(int argc, char **argv){

  7. int *p ,*q;

  8. char *pchar;

  9.  
  10. cout << " in main ,return_value0() :" << return_value0()<< endl<< endl;

  11.  
  12. p = return_value1();

  13. cout << " in main ,return_value1() :" << p<< " " << *p << endl<< endl;

  14.  
  15. p = return_value2();

  16. cout << " in main ,return_value2() :" << p<< " " << *p << endl<< endl;

  17.  
  18. q = p;

  19. cout << " before return_value3 , q: " << q << " " << *q <<endl<< endl;

  20. p = return_value3(q);

  21. cout << " in main ,return_value3() :" << p<< " " << *p << endl<< endl;

  22. cout << " after return_value3 , q: " << q << " " << *q <<endl<< endl;

  23.  
  24. pchar = return_value4();

  25. cout << " in main ,return_value3() :" << pchar<< " " << *pchar << endl<< endl;

  26.  
  27.  
  28. pchar = return_value5();

  29. cout << " in main ,return_value5() :" << pchar<< " " << *pchar << endl<< endl;

  30.  
  31.  
  32. pchar = return_value6();

  33. cout << " in main ,return_value6() :" << pchar<< " " << *pchar << endl<< endl;

  34.  
  35. system("pause");

  36. return 0;

  37. }

 
  1. #include <stdio.h>

  2. char *returnStr()

  3. {

  4. char *p="hello world!";

  5. return p;

  6. }

  7. int main()

  8. {

  9. char *str;

  10. str=returnStr();

  11. printf("%s\n", str);

  12. return 0;

  13. }

  14.  
  15. 这个没有任何问题,因为"hello world!"是一个字符串常量,存放在只读数据段,

  16. 把该字符串常量存放的只读数据段的首地址赋值给了指针,所以returnStr函数退出时,

  17. 该该字符串常量所在内存不会被回收,故能够通过指针顺利无误的访问。

 
  1. #include <stdio.h>

  2. char *returnStr()

  3. {

  4. char p[]="hello world!";

  5. return p;

  6. }

  7. int main()

  8. {

  9. char *str;

  10. str=returnStr();

  11. printf("%s\n", str);

  12. return 0;

  13. }

  14.  
  15. "hello world!"是局部变量存放在栈中。当returnStr函数退出时,栈要清空,

  16. 局部变量的内存也被清空了,所以这时的函数返回的是一个已被释放的内存地址,

  17. 所以有可能打印出来的是乱码。

 
  1. int func()

  2. {

  3. int a;

  4. ....

  5. return a; //允许

  6. }

  7.  
  8. int * func()

  9. {

  10. int a;

  11. ....

  12. return &a; //无意义,不应该这样做

  13. }

  14.  
  15. 局部变量也分局部自动变量和局部静态变量,由于a返回的是值,因此返回一个局部变量是可以的,无论自动还是静态,

  16.  
  17. 因为这时候返回的是这个局部变量的值,但不应该返回指向局部自动变量的指针,因为函数调用结束后该局部自动变量

  18.  
  19. 被抛弃,这个指针指向一个不再存在的对象,是无意义的。但可以返回指向局部静态变量的指针,因为静态变量的生存

  20.  
  21. 期从定义起到程序结束。

如果函数的返回值非要是一个局部变量的地址,那么该局部变量一定要申明为static类型。如下:

 
  1. #include <stdio.h>

  2. char *returnStr()

  3. {

  4. static char p[]="hello world!";

  5. return p;

  6. }

  7. int main()

  8. {

  9. char *str;

  10. str=returnStr();

  11. printf("%s\n", str);

  12.  
  13. return 0;

  14. }

数组是不能作为函数的返回值的,原因是编译器把数组名认为是局部变量(数组)的地址。返回一个数组一般用返回指向这个数组的指针代替,而且这个指针不能指向一个自动数组,因为函数结束后自动数组被抛弃,但可以返回一个指向静态局部数组的指针,因为静态存储期是从对象定义到程序结束的。如下:

 
  1. int* func( void )

  2. {

  3. static int a[10];

  4. ........

  5. return a;

  6. }

返回指向堆内存的指针是可以的

 
  1.  
  2. char *GetMemory3(int num)

  3. {

  4. char *p = (char *)malloc(sizeof(char) * num);

  5. return p;

  6. }

  7. void Test3(void)

  8. {

  9. char *str = NULL;

  10. str = GetMemory3(100);

  11. strcpy(str, "hello");

  12. cout<< str << endl;

  13. free(str);

程序在运行的时候用 malloc 申请任意多少的内存,程序员自己负责在何时用 free释放内存。动态内存的生存期由程序员自己决定,使用非常灵活。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值