函数作为左值(也就是返回非const引用)应该从c++中删除。这太不直观了。Scott Meyers想要一个min()的行为。

min(a,b) = 0;  // What???

这并不是真正的进步

setmin (a, b, 0);

后者甚至更有意义。

我意识到函数作为左值对于c++风格的流很重要，但值得指出的是，c++风格的流很糟糕。我不是唯一一个这样认为的人……我记得Alexandrescu有一篇关于如何做得更好的文章，我相信boost也试图创建一个更好的类型安全的I/O方法。

一般来说，返回引用是非常正常的，并且经常发生。

如果你的意思是:

int& getInt() {
    int i;
    return i;  // DON'T DO THIS.
}

那是各种各样的邪恶。stack-allocated i会消失，你什么都没有提到。这也是恶的。

int& getInt() {
    int* i = new int;
    return *i;  // DON'T DO THIS.
}

因为现在客户最终要做一些奇怪的事情:

int& myInt = getInt(); // note the &, we cannot lose this reference!
delete &myInt;         // must delete...totally weird and  evil

int oops = getInt(); 
delete &oops; // undefined behavior, we're wrongly deleting a copy, not the original

请注意，右值引用仍然只是引用，所以所有邪恶的应用程序都是一样的。

如果你想要分配一些超出函数范围的东西，使用智能指针(或者一般来说，一个容器):

std::unique_ptr<int> getInt() {
    return std::make_unique<int>(0);
}

现在客户端存储了一个智能指针:

std::unique_ptr<int> x = getInt();

引用也可以用于访问你知道生命期在更高级别上保持打开的东西，例如:

struct immutableint {
    immutableint(int i) : i_(i) {}

    const int& get() const { return i_; }
private:
    int i_;
};

在这里，我们知道返回对i_的引用是可以的，因为不管调用我们的是什么，它都管理着类实例的生命周期，所以i_至少会存在这么长时间。

当然，这并没有什么错:

int getInt() {
   return 0;
}

如果生命期应该留给调用者，而你只是在计算值。

总结:如果对象的生命周期不会在调用后结束，则可以返回引用。

它不仅不邪恶，而且有时是必不可少的。例如，如果不使用引用返回值，就不可能实现std::vector的[]操作符。

最好的方法是创建对象并将其作为引用/指针形参传递给分配该变量的函数。

在函数中分配对象并将其作为引用或指针返回(但指针更安全)是一个坏主意，因为会在函数块的末尾释放内存。

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

让我们来分析以下案例:

错误的用法

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!

我认为使用reference作为函数的返回值比使用pointer作为函数的返回值要直接得多。 其次，使用返回值所指向的静态变量总是安全的。