解引用map迭代器返回临时对象引用的编译警告问题咨询

Let's break down the problem by first looking at the two code snippets and their behavior, then diving into the root cause.

Vector-based code (compiles cleanly with Clang and GCC) #

#include <iterator>
#include <vector>
const int& foo(const std::vector<int>& x,unsigned i) {
    auto it = x.begin();
    std::advance(it,i);
    return *it;
}

This code works as expected on both compilers because everything lines up perfectly: dereferencing a const vector<int> iterator gives you a const int&, which exactly matches the function's return type. No conversions or temporary objects are created—we're just returning a direct reference to an element in the vector.

Map-based code (errors with Clang + -Werror) #

#include <iterator>
#include <map>
const std::pair<int,int>& bar(const std::map<int,int>& x,unsigned i){
    auto it = x.begin();
    std::advance(it,i);
    return *it;
}

When compiling this with Clang and the -Werror flag, you hit the error: 'return reference to temporary when dereferencing map iterator'. Here's why this happens:

The core issue: Map value types are not what you think #

std::map has a critical detail you might miss: its elements are actually std::pair<const Key, Value>, not std::pair<Key, Value>. This is because map keys are immutable once inserted—changing a key in-place would break the map's sorted ordering, so the standard enforces this by making the key part of the pair const.

Your function bar declares a return type of const std::pair<int,int>&, but dereferencing the map iterator gives you a const std::pair<const int, int>&. These two types don't match: the first member of the pair has different const-qualification. To bridge this gap, the compiler has to create a temporary copy of the pair (converting const int to int for the first member).

When you return a reference to this temporary object, the temporary gets destroyed as soon as the function exits, leaving you with a dangling reference. Clang's -Werror (which elevates warnings to errors) catches this unsafe pattern, while GCC might not flag it as aggressively by default.

Fixing the code #

To resolve this, you need to match the return type to the map's actual value type:

// Explicitly use the map's value type
const std::pair<const int, int>& bar(const std::map<int,int>& x,unsigned i){
    auto it = x.begin();
    std::advance(it,i);
    return *it;
}

Or, if you're using C++11 or later, let the compiler deduce the correct return type automatically with decltype(auto):

decltype(auto) bar(const std::map<int,int>& x,unsigned i){
    auto it = x.begin();
    std::advance(it,i);
    return *it;
}

内容的提问来源于stack exchange，提问作者463035818_is_not_an_ai