Std :: ignore için volatile rvalue atama reddetmek için libstdC++ yanlış mı?

Question

Bu libstdC++ uygulamasının std::ignore numaralı uygulamasının, bir uçucu rıhtıya bağlanamayan bir const T& argümanını aldığını fark ettim. Böylece, aşağıdaki kod derlenmeyecektir:

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

bu standart ihlal mı veya bu tanımsız davranış hale getiren bir madde bulunmamaktadır?

Answer 1

Dil avukatı değilim, bu yüzden bu soruyu olabildiğince doğrudan yanıtlayacağım.

ignore

gibi tuple.general içinde tuple arasında özet bulunur:

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

Fark gibi, libstdc++ uygulama aşağıdaki gibi ignore tanımlar: libc++ versiyonu gibi tanımlar

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

Oysa Bu:

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

Bu şekilde, libC++ derler. Şimdi std::tie tanımı [tuple.creation] bulunabilir diyor ki:

İade: tuple<Types&...>(t...). t'daki bir argüman ignore olduğunda, ilgili tuple elemanına herhangi bir değer atamak etkisizdir.

Bu ignore kendisi hakkında hiçbir şey söylemez, bu yüzden belirtilmemiş davranışa bu kadar tebeşir gidiyorum. undefined davranışını ihmal ederek tartışabilirsiniz, ancak bu onu genişletiyor olabilir.

Answer 2

Yorum:

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