Chinaunix

标题: 为什么不能返回函数内部new分配的内存的引用？ [打印本页]

作者: user2003 时间: 2009-10-15 17:28
标题: 为什么不能返回函数内部new分配的内存的引用？
按照这句话，
string& foo()
{
string* str = new string("abc");
return *str;
}
非法的，为什么？

作者: net_robber 时间: 2009-10-15 17:35
主观臆断了，这里删掉了，看后面回复
http://bbs3.chinaunix.net/viewth ... ;page=1#pid11353088

[ 本帖最后由 net_robber 于 2009-10-16 12:19 编辑 ]

作者: flyingzhuang 时间: 2009-10-15 19:28
局部变量

bool foo(string*& strPoint)
{
string* str = new string("abc");
return str ? strPoint = str, true : false;
}

作者: drangon 时间: 2009-10-15 23:13
标题: 回复 #1 user2003 的帖子
什么叫做非法？

这段代码编译没问题，运行没问题，有问题的地方是会内存泄露

作者: user2003 时间: 2009-10-16 08:58
struct a_s
{
int a;
};

a_s* foo()
{
struct a_s* sp = new struct a_s;
return sp;
}

这个挺好啊，为什么换成reference就泄漏了？

作者: lxin_1987 时间: 2009-10-16 09:02
标题: 回复 #5 user2003 的帖子
没有delete撒

作者: 星空天神 时间: 2009-10-16 09:28
delete &reference,不过这样写很诡异

作者: garymb 时间: 2009-10-16 11:09
你要搞清楚的是返回对象的引用和直接返回对象的区别，返回引用意味着你是直接返回对象本身，而直接返回对象是复制对象，那么你的第一个代码

string& foo()
{
string* str = new string("abc");
return *str;
}

里面返回的是一个局部变量*str,这个肯定是错误的，你的局部对象在函数返回就被销毁了，把他返回有何意义？（谢谢9楼的提醒，我这里说错了，*str并未被销毁，但是他仍然只是一个值，11楼我做了说明）至于你提到的第二份代码

struct a_s
{
int a;
};

a_s* foo()
{
struct a_s* sp = new struct a_s;
return sp;
}

你返回的是什么，一个地址，这个地址虽说也是局部变量，但是由于你是用new申请的堆变量，除非你手动释放，这块内存是不会释放的(理论上),于是你很幸运，这个指针在程序运行期间一直能引用到正确的内存地址，而且更重要的是你返回他，并不是得到返回他本身(说过局部变量的生命期只在函数执行期间).而是该对象的复制，对，一个地址的值而已，所以不会出错，但是问题就是你的程序后面无法释放这一块内存，因为delete操作是根据不同的类型调用不同的析构函数，但是上面的函数返回时，你就失去了这个局部变量的一切，除开他的内存地址.
再说说内存泄漏的问题，我们new了一块内存，然后用delete释放他，这是C++对程序员的要求，但是实际上对现代操作系统，垃圾回收机制使得在程序结束时系统会帮你释放其占用的控件,可以说上面的new了没释放并非语法上的错误，而是编程习惯的隐患。
另外说一点，楼主去看看C++Primer，哪些情况下才引用类型的返回值
简单说下

string & shorterString(string &s1,string &s2)
{
return s1.size()<s2.size()? s1:s2; //返回

//的是s1,或者s2.是你传递引用类型形参.

//看了下面的两个函数你会发现,传递的形参里

//至少有一个是引用. .是用来被返回的.

}

不要返回局部对象的引用.

const string &manip(const string&s)
{
string ret=s;
return ret;// 错误,ret为局部对象.

}

引用返回左值.(这个是和返回类对象的一个很大的区别)

char &get_val(string &str,int ix)
{
return str[ix];
}

int main()
{
string s("a value");
cout<<s<<endl;
get_val(s,0)='A'; // 这里可以用来赋值的,

cout<<s<<endl;
return 0;
}

例子摘自C++Primer

[ 本帖最后由 garymb 于 2009-10-16 12:43 编辑 ]

作者: drangon 时间: 2009-10-16 11:45
标题: 回复 #8 garymb 的帖子
不要误导
[quota]
里面返回的是一个局部变量*str,这个肯定是错误的，你的局部对象在函数返回就被销毁了，把他返回有何意义？至于你提到的
[/quota]

str是局部变量，但*str不是局部变量，是实实在在new出来的，函数返回时str会销毁，但*str是不会销毁的。

作者: net_robber 时间: 2009-10-16 12:19

# cat t.cpp

复制代码

#include <iostream>
#include <string>
using namespace std;

string& foo()
{
        string* str = new string("abc");
        return *str;
}
int main()
{
        string& a=foo();
        cout<<a;
}

# g++ t.cpp
# ./a.out
abc#

复制代码

[ 本帖最后由 net_robber 于 2009-10-16 12:22 编辑 ]

作者: garymb 时间: 2009-10-16 12:40
恩，是str被销毁，我没说明白，*str仍然得到的是实实在在的值，就算*str能够获得正确的值，他也仅仅只是一个值而已，10楼这段代码是能正确运行，我只是根据楼主说的"非法"做一些说明，首先你为什么会用引用？因为用引用能够得到对象本身，就像我在后面说到的，他是能够做左值的，一言以蔽之，你的程序没有错误，但是你指定的引用返回类型毫无意义，你返回的并非一个对象，而是一个对象的复制，但是你却给了他一个引用类型。

作者: syncpk99 时间: 2009-10-16 12:42
楼主这种写法编译运行能够获得预期的结果，只是这个函数经常被调用，比如几百几千万次，可以观察一下程序占用的内存数一直在增长。因为不对foo的返回值做处理，new出来的对象一直不会销毁。

作者: syncpk99 时间: 2009-10-16 12:49

#include <iostream>
#include <string>

using namespace std;

string& foo()
{
        string* str = new string("abc");
        cout << "Address in foo:" << str << endl;
        return *str;
}

int main(int argc,char *argv[])
{
    for(int i = 0; i < 10; ++i)
    {
        string *str1 = &foo();
        cout << *str1 << endl;
        cout << "Address in main:" << str1 << endl;
        //delete str1;

    }
    
    return 0;
}

在AIX上运行输出如下：
Address in foo:20003068
abc
Address in main:20003068
Address in foo:200030e8
abc
Address in main:200030e8
Address in foo:20003138
abc
Address in main:20003138
Address in foo:20003158
abc
Address in main:20003158
Address in foo:200045e8
abc
Address in main:200045e8

可以看出，返回的确实是foo中new出的对象。

作者: garymb 时间: 2009-10-16 13:14
标题: 回复 #13 syncpk99 的帖子
哎。。糗了，实践出真知。。这个东西没什么非法的东西，除了没有释放。

作者: rain_fish 时间: 2009-10-16 14:20

原帖由 garymb 于 2009-10-16 11:09 发表
你要搞清楚的是返回对象的引用和直接返回对象的区别，返回引用意味着你是直接返回对象本身，而直接返回对象是复制对象，那么你的第一个代码
string& foo()
{
string* str = new string("abc");
ret ...

你返回的是什么，一个地址，这个地址虽说也是局部变量，但是由于你是用new申请的堆变量，除非你手动释放，这块内存是不会释放的(理论上),于是你很幸运，这个指针在程序运行期间一直能引用到正确的内存地址，而且更重要的是你返回他，并不是得到返回他本身(说过局部变量的生命期只在函数执行期间).而是该对象的复制，对，一个地址的值而已，所以不会出错，但是问题就是你的程序后面无法释放这一块内存，因为delete操作是根据不同的类型调用不同的析构函数，但是上面的函数返回时，你就失去了这个局部变量的一切，除开他的内存地址.
兄台这句话貌似是错误的：
a_s* as_tmp = foo();
delete as_tmp;

有何不可？

作者: rain_fish 时间: 2009-10-16 14:27
标题: 回复 #1 user2003 的帖子
不能返回函数内部new分配的内存的引用。这条可以参照Effective C++[1]的Item 31。虽然不存在局部变量的被动销毁问题，可对于这种情况（返回函数内部new分配内存的引用），又面临其它尴尬局面。例如，被函数返回的引用只是作为一个临时变量出现，而没有被赋予一个实际的变量，那么这个引用所指向的空间（由new分配）就无法释放，造成memory leak。

不是不可以，而是不好，不推荐这么用。

作者: koolcoy 时间: 2009-10-16 15:10
就真确性来说这种用法是没问题的。但是这样做不优雅 1. delete &str让人很抓狂。2. 内存使用应该尽量做到谁分配谁释放的原则。

作者: 020794 时间: 2009-10-20 12:38
对于“返回函数内部new分配的内存的引用”

语法上，没问题。

逻辑上，这就类似于工厂函数先new一个对象，然后返回该对象的指针一样。只不过这里改为返回引用，也没什么欠妥的地方。

综上，个人以为没什么“非法”的地方。

欢迎光临 Chinaunix (http://bbs.chinaunix.net/)