Czy libstdC++ jest błędne, aby odrzucić przypisanie zmiennej rvalue do std :: ignore?

Question

Zauważyłem, że implementacja libstdC++ z std::ignore przyjmuje argument const T&, który nie może wiązać się z niestabilnym rwartem. Stąd poniższy kod nie kompilacji:

#include <tuple> 
#include <utility> 
struct C {}; 
using VC = C volatile; 
int main() { 
    std::tuple<VC> t; 
    std::tie(std::ignore) = std::move(t); 
} 

(http://coliru.stacked-crooked.com/a/7bfc499c1748e59e)

Czy to z naruszeniem normy, czy też istnieje klauzula, która czyni tę niezdefiniowanej zachowanie?

Answer 1

Nie jestem prawnikiem językowym, więc odpowiem na to pytanie tak bezpośrednio, jak to możliwe.

ignore znajduje się w streszczeniu tuple w tuple.general jako takie:

// [tuple.creation], tuple creation functions: 
const unspecified ignore; 

Jak zauważył, wdrożenie libstdc++ definiuje ignore tak:

// A class (and instance) which can be used in 'tie' when an element 
    // of a tuple is not required 
    struct _Swallow_assign 
    { 
    template<class _Tp> 
     const _Swallow_assign& 
     operator=(const _Tp&) const 
     { return *this; } 
    }; 

Podczas gdy wersja libc++ definiuje ją jak to:

template <class _Up> 
struct __ignore_t 
{ 
    template <class _Tp> 
     _LIBCPP_INLINE_VISIBILITY 
     const __ignore_t& operator=(_Tp&&) const {return *this;} 
}; 

Jako taki, kompiluje się w libC++. Teraz definicja std::tie można znaleźć w [tuple.creation], który mówi:

Powroty: tuple<Types&...>(t...). Gdy argument w t jest ignore, przypisanie dowolnej wartości do odpowiedniego elementu krotki ma brak efektu.

ten nie mówi nic o samej ignore, więc mam zamiar kreda to do nieokreślonym zachowanie. Można argumentować, że jest to zachowanie nieokreślone przez zachowanie, ale może to być rozciąganie.

Answer 2

Komentarz:

// g++ 4.8.4 
int main() { 
    volatile int vi; 
    std::ignore = vi; 

    // error: no match for ‘operator=’ (
    //  operand types are ‘const std::_Swallow_assign’ 
    //  and ‘std::remove_reference<volatile int&>::type {aka volatile int}’ 
    //) 
    // std::ignore = std::move(vi); 

    // However this compiles: 
    volatile int&& vir = std::move(vi); 
    std::ignore = vir; 
}