const auto& to integer with std::min std::max - c++

Question

I have these codes below. What's wrong with the const auto& in this context, it caused unexpected outputs.
It works fine while compiled with gcc-4.8.5, but gets unexpected outputs with gcc-4.9.2.
If I remove the & in const auto&, it works fine with both gcc versions.
// max_dim is a protobuf filed: const auto max_dim = msg.max();
// cat2_num is an element in std::vector<int32_t>: const auto cat2_num = vec[i]
const auto& res_num = std::max(1, std::min(max_dim, cat2_num));
LOG(ERROR) << res_num << ", " << max_dim << ", " << cat2_num
<< ", " << std::max(1, std::min(max_dim, cat2_num));
outputs:
-1392522416, 3, 1, 1
2, 3, 2, 2
3, 3, 3, 3
-1392522416, 3, 1, 1
3, 3, 6, 3
2, 3, 2, 2
-1392522416, 3, 1, 1
-1392522416, 3, 1, 1
2, 3, 2, 2
=========== updated ========
I couldn't reproduce the undefined behavior with these codes:
#include <iostream>
#include <vector>
int main() {
std::vector<int32_t> v = {-1, 0, 1, 2, 3, 6};
const int a = 3;
const auto& b = a;
for(size_t i = 0; i < v.size(); i++) {
const auto& c = v[i];
const auto& d = std::max(1, std::min(b, c));
std::cout << d << ", " << b << ", " << c << std::endl;
}
return 0;
}
output:
1, 3, -1
1, 3, 0
1, 3, 1
2, 3, 2
3, 3, 3
3, 3, 6

Answer 1

Your code has undefined behavior. In
const auto& res_num = std::max(1, std::min(max_dim, cat2_num));
The 1 is a prvalue, so a temporary integer is created that gets bound to the function parameter. This would be okay of max was like
template <typename T> const T max(const T&, const T&);
but instead it is defined like
template <typename T> const T& max(const T&, const T&);
So, if that 1 happens to be the maximum value, then max returns to you a reference to that temporary object that was created. After that, the temporary object is destroyed1, leaving res_num as a dangling reference. To fix the code make res_num a non-reference like
const auto res_num = std::max(1, std::min(max_dim, cat2_num));
and now you get a copy of the correct value.
1: all temporaries are destroyed at the end of the full expression the are created in

Answer 2

#NathanOliver has given clear declaration for the cause. Here is some other related infomation.
const T& is helpful for large objects, but it involves lifetime and aliasing problem. So be careful.
For int, double, pointers values, const T& gains nothing. In this situation, copy is cheaper than reference.
reference: int vs const int&