Obserwowanie dziwnego zachowania za pomocą "auto" i std :: minmax

Question

Używam GCC 4.7.2 i Boost 1.58.0 na SUSE Enterprise Linux 11. Mam następujący fragment kodu, który zasadniczo przechodzi przez listę wielokątów, aby obliczyć ich długość/szerokość. Widzę dziwne dane wyjściowe podczas używania słowa kluczowego "auto" z funkcją std :: minmax. Dla porównania deklaruję również drugą zmienną, w której typy są jawnie deklarowane (tj. Dim a dim1).

namespace gtl = boost::polygon; 
typedef gtl::polygon_90_data<int> LayoutPolygon; 
typedef gtl::rectangle_data<int> LayoutRectangle; 
static LayoutFeatureVec 
calc_stats(LayoutPolygonSet const& lp) 
{ 
    LayoutFeatureVec v; 
    LayoutFeature f; 
    LayoutRectangle y; 
    for (LayoutPolygon const& p : lp) { 
     // Compute bounds. 
     gtl::extents(y, p); 

     // Get width/length (shorter/longer). 
     // FIXME: Why does this not work with auto?? 
     cout << gtl::delta(y, gtl::HORIZONTAL) << " " << gtl::delta(y, gtl::VERTICAL) << endl; 

     auto dim = std::minmax(gtl::delta(y, gtl::HORIZONTAL), 
          gtl::delta(y, gtl::VERTICAL)); 

     std::pair<int, int> dim1 = std::minmax(gtl::delta(y, gtl::HORIZONTAL), 
              gtl::delta(y, gtl::VERTICAL)); 

     cout << dim.first << " " << dim.second << endl; 
     cout << dim1.first << " " << dim1.second << endl; 

     <snip> 
     v.push_back(f); 
    } 

    return v; 
} 

Dla pierwszej iteracji tej pętli oczekiwane wyjście jest poprawne.

380 420 
380 420 
380 420 

Jednak gdybym wykomentuj 'dim1' i ponownie ten sam kod (czyli po prostu auto DIM), mam dziwne wyniki z std :: MinMax.

380 420 
140737295994126 140737295994126 

Co ja tu robię źle?

Oto minimalny przykład (edytowany na podstawie odpowiedzi poniżej).

#include <iostream> 
#include <algorithm> 
#include <boost/polygon/polygon.hpp> 

using namespace std; 

namespace gtl = boost::polygon; 
using namespace gtl::operators; 

int main(int argc, char** argv) 
{ 
    gtl::rectangle_data<int> x(0,0,5,5); 

    auto dim = std::minmax(gtl::delta(x, gtl::HORIZONTAL), gtl::delta(x, gtl::VERTICAL)); 
    cout << dim.first << " " << dim.second << endl; 

    return 0; 
} 

Answer 1

Jest to jeden z tych przypadków, gdzie nieauto używać jako specyfikacja typu. std::minmax zwraca parę odniesień:

template< class T > 
std::pair<const T&,const T&> minmax(const T& a, const T& b); 

to co auto będzie wydedukować. Ale delta() zwraca tymczasowy. Więc kiedy piszesz:

auto dim = std::minmax(gtl::delta(y, gtl::HORIZONTAL), 
         gtl::delta(y, gtl::VERTICAL)); 

dim trzyma dwa wiszące odniesienia. Ale kiedy piszesz:

std::pair<int, int> dim1 = std::minmax(...); 

Po prostu trzymasz wartości bezpośrednio. Właśnie dlatego działa, ale nie działa. Dodatkowa konwersja, którą wykonujesz, uniemożliwia trzymanie zwisających referencji.

---

Alternatywnie, i pod względem kompletności, można użyć innego przeciążenie minmax że nie zwraca nazwy:

template< class T > 
std::pair<T,T> minmax(std::initializer_list<T> ilist); 

który właśnie wprowadza pewne dodatkowe szelki:

auto dim2 = std::minmax({gtl::delta(y, gtl::HORIZONTAL), 
         gtl::delta(y, gtl::VERTICAL)}); 

But Proponuję właśnie jawnie nazwać typ. Wydaje mi się to mniej podatne na błędy.