最重要的一点:函数不能返回指向栈内存的指针!
为什么?因为返回的都是值拷贝!
一般的来说,函数是可以返回局部变量的。 局部变量的作用域只在函数内部,在函数返回后,局部变量的内存已经释放了。因此,如果函数返回的是局部变量的值,不涉及地址,程序不会出错。但是如果返回的是局部变量的地址(指针)的话,程序运行后会出错。因为函数只是把指针复制后返回了,但是指针指向的内容已经被释放了,这样指针指向的内容就是不可预料的内容,调用就会出错。准确的来说,函数不能通过返回指向栈内存的指针(注意这里指的是栈,返回指向堆内存的指针是可以的)。
我们知道,局部变量的作用域是函数内部,函数一旦执行结束,栈上的局部变量会进行销毁,内存得到释放。因此,此时函数返回的是该局部变量的值拷贝,这是没有问题的。但是如果返回的是局部变量的地址,那么返回的只是该局部变量指针的拷贝,而随着函数运行结束,该拷贝指针所指向的栈内存已经被释放,那么指向一个未知区域就会导致调用的错误。
那如果返回的指针指向的是堆内存,又会怎么样?
这样的使用是没有问题的,在函数内new空间,在函数外delete空间。但是这样并不是一种好的编程风格,尽量在同一个作用域内进行new和delete操作,否则还要调用者手动进行内存的释放,试问这样的接口是不是很烂。如果确实需要这样做,那就传指针进去吧!
#include "fun_stdy.h"
#include <iostream>
using namespace std;
int return_value0(){
int ret = 0;
cout << " in return_value0 , address and value:"<< &ret <<" "<< ret <<endl;
return ret; //ok 最常见的情况, 返回局部变量的副本
}
int* return_value1()
{
int ret=1;
cout << " in return_value1 , and value:"<< &ret<<" " << ret <<endl;
return &ret; //error 虽然value被释放 , 但里面的值可能不会被清除,所以有时候你这么用
//看起来结果好像也是对的,但是隐患无穷。
}
int* return_value2()
{
int *ret = new int(2);
cout << " in return_value2 , address and value:"<< &ret <<" " << ret <<endl;
return ret; //ok 在函数内申请空间,调用后需要调用者手动在函数外释放空间
}
int* return_value3(int *ret) //指针value不能为null,否则报错
{
ret = new int(3);
cout << " in return_value3 , address and value:"<< &ret<<" " << ret <<endl;
return ret; //ok 在函数内申请空间,调用后需要调用者手动在函数外释放空间
}
char *return_value4()
{
char p[] = "hello world";
cout << " in return_value4 , address and value:"<< &p<<" " << p <<endl;
return p; //p[]数组为函数内部局部变量,在函数返回后,内存已经被释放了,
//所以在主函数中调用该函数str2 = return_value3();输出的可能为乱码
}
//此函数中p也是个局部变量,函数执行完自动销毁,但是指针分配的空间不会被自动回收,除非程序员delete掉。
//所以这个可以正常输出。
char *return_value5()
{
char *p = "hello world";//这个初始化的一种形式,相当于分配了sizeof(hello world)个空间
cout << " in return_value5 , address and value:"<< &p <<" "<< p << endl;
return p;
}
/* 如果真要返回局部变量的引用和指针 ,请用static */
char *return_value6()
{
static char p[] = "hello world";
cout << " in return_value6 , static_pointer's address and value:"<< &p <<" "<< p << endl;
return p;
}
#include <iostream>
#include "fun_stdy.h"
using namespace std;
int main(int argc, char **argv){
int *p ,*q;
char *pchar;
cout << " in main ,return_value0() :" << return_value0()<< endl<< endl;
p = return_value1();
cout << " in main ,return_value1() :" << p<< " " << *p << endl<< endl;
p = return_value2();
cout << " in main ,return_value2() :" << p<< " " << *p << endl<< endl;
q = p;
cout << " before return_value3 , q: " << q << " " << *q <<endl<< endl;
p = return_value3(q);
cout << " in main ,return_value3() :" << p<< " " << *p << endl<< endl;
cout << " after return_value3 , q: " << q << " " << *q <<endl<< endl;
pchar = return_value4();
cout << " in main ,return_value3() :" << pchar<< " " << *pchar << endl<< endl;
pchar = return_value5();
cout << " in main ,return_value5() :" << pchar<< " " << *pchar << endl<< endl;
pchar = return_value6();
cout << " in main ,return_value6() :" << pchar<< " " << *pchar << endl<< endl;
system("pause");
return 0;
}
#include <stdio.h>
char *returnStr()
{
char *p="hello world!";
return p;
}
int main()
{
char *str;
str=returnStr();
printf("%s\n", str);
return 0;
}
这个没有任何问题,因为"hello world!"是一个字符串常量,存放在只读数据段,
把该字符串常量存放的只读数据段的首地址赋值给了指针,所以returnStr函数退出时,
该该字符串常量所在内存不会被回收,故能够通过指针顺利无误的访问。
#include <stdio.h>
char *returnStr()
{
char p[]="hello world!";
return p;
}
int main()
{
char *str;
str=returnStr();
printf("%s\n", str);
return 0;
}
"hello world!"是局部变量存放在栈中。当returnStr函数退出时,栈要清空,
局部变量的内存也被清空了,所以这时的函数返回的是一个已被释放的内存地址,
所以有可能打印出来的是乱码。
int func()
{
int a;
....
return a; //允许
}
int * func()
{
int a;
....
return &a; //无意义,不应该这样做
}
局部变量也分局部自动变量和局部静态变量,由于a返回的是值,因此返回一个局部变量是可以的,无论自动还是静态,
因为这时候返回的是这个局部变量的值,但不应该返回指向局部自动变量的指针,因为函数调用结束后该局部自动变量
被抛弃,这个指针指向一个不再存在的对象,是无意义的。但可以返回指向局部静态变量的指针,因为静态变量的生存
期从定义起到程序结束。
如果函数的返回值非要是一个局部变量的地址,那么该局部变量一定要申明为static类型。如下:
#include <stdio.h>
char *returnStr()
{
static char p[]="hello world!";
return p;
}
int main()
{
char *str;
str=returnStr();
printf("%s\n", str);
return 0;
}
数组是不能作为函数的返回值的,原因是编译器把数组名认为是局部变量(数组)的地址。返回一个数组一般用返回指向这个数组的指针代替,而且这个指针不能指向一个自动数组,因为函数结束后自动数组被抛弃,但可以返回一个指向静态局部数组的指针,因为静态存储期是从对象定义到程序结束的。如下:
int* func( void )
{
static int a[10];
........
return a;
}
返回指向堆内存的指针是可以的
char *GetMemory3(int num)
{
char *p = (char *)malloc(sizeof(char) * num);
return p;
}
void Test3(void)
{
char *str = NULL;
str = GetMemory3(100);
strcpy(str, "hello");
cout<< str << endl;
free(str);
程序在运行的时候用 malloc 申请任意多少的内存,程序员自己负责在何时用 free释放内存。动态内存的生存期由程序员自己决定,使用非常灵活。