c++ - decltype(auto) foo() 在没有任何警告的情况下返回本地引用

Question

在使用现代 C++ 中的示例时，我编写了以下代码。

#include <string>
#include <iostream>

static int count = 0;

class Counter
{
public:
    Counter() { ++count; };
    Counter(Counter& r) { ++count; };
    Counter(Counter&& r) { ++count; };
    ~Counter() { --count; };

    void foo() {};
};

decltype(auto) foo_warn()
{
    Counter c;
    return (c);             // Warning about returning local reference
}

decltype(auto) foo_no_warn()
{
    Counter c;
    return 1==1 ? c : c;    // No warning, still local reference returned
}

int main()
{
    Counter& a = foo_warn();
    Counter& b = foo_no_warn();

    std::cout << count << std::endl;  // prints 0

    a.foo();
    b.foo();

    return 0;
}

使用命令编译的代码:

g++-6 -std=c++14 -Wall -O0 decl_fail.cpp -o decl_fail

输出:

g++-6 -std=c++14 -Wall -O0    decl_fail.cpp   -o decl_fail
decl_fail.cpp: In function ‘decltype(auto) foo_warn()’:
decl_fail.cpp:19:10: warning: reference to local variable ‘a’ returned [-Wreturn-local-addr]
  Counter a;
          ^

我很清楚 decltype(auto) 返回表达式的引用(但仍然不直观)，因此 a 和 b 是无效引用(由 count==0 证明)。

问题是为什么编译器没有在 foo_no_warn 中警告我？

我是在编译器中发现了错误还是这是某种可以解释的行为？

Answer 1

首先让我们声明问题与 decltype(auto) 没有显式相关，因为如果函数显式返回 Counter&，您将得到几乎相同的结果。

您可以考虑以下代码:

typedef std::vector<int> Type;

class DataContainer {
public:
    DataContainer() : data(Type(1024, 0)) {}
    const Type& getData() const { return data; }

private:
    const Type data;
};

const Type& returnLocalRef()
{
    DataContainer container;
    const Type& data = container.getData();
    return data; // o! returning a ref to local - no warning for most compilers
}

虽然返回了本地引用，但编译器在 VS2015 和 gcc48(使用 -Wall)中都没有发出警告。但是，如果您从 const Type& data 中删除引用，编译器会立即发现问题。您应该将这种行为视为错误吗？有争议。

编译器的基本工作是编译代码。它警告开发人员注意一些明显的问题，但在大多数情况下，它不会对程序逻辑进行任何更深入的分析(编译时间会受到影响)。 这就是开发和应该使用代码静态分析工具的目的。

所描述的情况可以被认为是一个简单的例子，但单层间接就足以“愚弄”编译器。因为要验证这一点，编译器需要检查从 getData 方法实际返回的内容。

做一个简单的修改:

Type globalData;
...
const Type& getData() const { return globalData; }

将使从 returnLocalRef 函数返回的引用有效。 因此，这可以被认为是编译器在分析复杂性和时间效率之间的权衡。