Ist libstdC++ falsch, um die Zuweisung von flüchtigem rvalue zu std :: ignore abzulehnen?

Question

Ich bemerkte, dass libstdC++ die Implementierung von std::ignore ein const T& Argument, das nicht an einen flüchtigen rvalue binden kann. Daher schlägt der folgende Code zu kompilieren:

#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)

Ist dies eine Verletzung der Norm, oder gibt es eine Klausel, die dieses nicht definiertes Verhalten macht?

Answer 1

Ich bin kein Sprachanwalt, also werde ich diese Frage so direkt wie möglich beantworten.

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

Wie Sie bemerkt haben, die libstdc++ Implementierung definiert ignore wie folgt aus:: es

// 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; } 
    }; 

Während die libc++ Version definiert wie

ignore in der Synopse von tuple in tuple.general als solche gefunden wird dies:

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

Als solche kompiliert es in libC++. Nun ist die Definition von std::tie in [tuple.creation] zu finden, die sagt:

Returns: tuple<Types&...>(t...). Wenn ein Argument in t ignore ist, hat das Zuweisen eines beliebigen Werts zum entsprechenden Tupelelement keinen Effekt.

sagen Dies nichts über ignore selbst, so dass ich dies zu nicht spezifiziert Verhalten gehen ankreiden. Sie können argumentieren, es ist undefined Verhalten durch Auslassung, aber das könnte es dehnen.

Answer 2

Kommentar:

// 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; 
}