我认为这有点主观;我不确定意见是否一致(我见过许多返回引用的代码片段)。

根据对我刚才问的这个问题的评论,关于初始化引用,返回一个引用可能是邪恶的,因为(据我所知)它更容易错过删除它,这可能导致内存泄漏。

这让我很担心,因为我已经遵循了一些例子(除非是我想象的事情),并且在相当多的地方这样做了……我误解了吗?它邪恶吗?如果是的话,到底有多邪恶?

我觉得因为我的指针和引用的混合包,加上我是c++的新手,以及完全不知道什么时候用什么,我的应用程序一定是内存泄漏的地狱…

另外,我知道使用智能/共享指针被普遍认为是避免内存泄漏的最佳方法。


当前回答

对已接受答案的补充:

Struct immutableint { Immutableint (int i): i_(i) {} Const int& get() Const{返回i_;} 私人: int i_; };

我认为这个例子是不好的,如果可能的话应该避免。为什么?很容易以悬空引用结束。

用一个例子来说明这一点:

struct Foo
{
    Foo(int i = 42) : boo_(i) {}
    immutableint boo()
    {
        return boo_;
    }  
private:
    immutableint boo_;
};

进入危险区域:

Foo foo;
const int& dangling = foo.boo().get(); // dangling reference!

其他回答

No.

不好的是引用动态分配的对象而丢失了原来的指针。当你新建一个对象时,你承担了保证删除的义务。

但是看一下,例如,操作符<<:必须返回一个引用,或者

cout << "foo" << "bar" << "bletch" << endl ;

不能工作。

这并不邪恶。像c++中的许多东西一样,如果使用正确,它是好的,但在使用它时应该注意许多陷阱(比如返回对局部变量的引用)。

有一些好的东西可以用它来实现(比如map[name] = "hello world")

我遇到了一个真正的问题,它确实是邪恶的。本质上,开发人员返回了对vector中对象的引用。太糟糕了!!

完整的细节我在一月份写过:http://developer-resource.blogspot.com/2009/01/pros-and-cons-of-returing-references.html

我发现这些答案不令人满意,所以我要发表我的意见。

让我们来分析以下案例:

错误的用法

int& getInt()
{
    int x = 4;
    return x;
}

这显然是错误的

int& x = getInt(); // will refer to garbage

静态变量的使用

int& getInt()
{
   static int x = 4;
   return x;
}

这是正确的,因为静态变量在程序的整个生命周期中都存在。

int& x = getInt(); // valid reference, x = 4

这在实现单例模式时也很常见

class Singleton
{
    public:
        static Singleton& instance()
        {
            static Singleton instance;
            return instance;
        };

        void printHello()
        {
             printf("Hello");
        };

};

用法:

 Singleton& my_sing = Singleton::instance(); // Valid Singleton instance
 my_sing.printHello();  // "Hello"
    

运营商

标准库容器在很大程度上依赖于返回引用的操作符的使用

T & operator*();

可用于以下

std::vector<int> x = {1, 2, 3}; // create vector with 3 elements
std::vector<int>::iterator iter = x.begin(); // iterator points to first element (1)
*iter = 2; // modify first element, x = {2, 2, 3} now

快速访问内部数据

有时&可以用于快速访问内部数据

Class Container
{
    private:
        std::vector<int> m_data;

    public:
        std::vector<int>& data()
        {
             return m_data;
        }
}

的用法:

Container cont;
cont.data().push_back(1); // appends element to std::vector<int>
cont.data()[0] // 1

然而,这可能会导致如下陷阱:

Container* cont = new Container;
std::vector<int>& cont_data = cont->data();
cont_data.push_back(1);
delete cont; // This is bad, because we still have a dangling reference to its internal data!
cont_data[0]; // dangling reference!

有两种情况:

Const引用——有时是个好主意,特别是对于重载对象或代理类,编译器优化 非const引用——有时是个坏主意,会破坏封装

两者都有同样的问题——可能指向被破坏的对象……

我建议在需要返回引用/指针的许多情况下使用智能指针。

另外,还要注意以下几点:

有一个正式的规则- c++标准(如果你感兴趣,请参阅13.3.3.1.4节)声明临时对象只能绑定到const引用-如果你试图使用非const引用,编译器必须将其标记为错误。