noexcept espressione vs tipo tratti

Question

Sto imparando come usare condizionale noexcept e imbattersi in questo problema. Supponiamo che io sono una classe:

template<typename T> 
class Wrapper { 
public: 
    Wrapper(T&& value) noexcept(/* ??? */) 
     : value_(std::move(value)) 
    {} 

private: 
    T value_; 
}; 

Per la parte /* ??? */, ho pensato che possiamo usare sia noexcept(T(std::move(value))) o std::is_nothrow_move_constructible<T>::value, fino a quando sono incappato in this.

Quindi, se io uso noexcept(noexcept(T(std::move(value)))), a rigor di termini che sto dicendo che "questo costruttore è noexcept se e solo se la costruzione e distruggendo un T è noexcept"?

Anche se i distruttori che lanciano devono essere messi a fuoco e bruciati.

Answer 1

Buona domanda, vedere anche this language defect discussion. Dal suo nome appare chiaro che std::is_nothrow_move_constructible<T>::valuedovrebbe riferirsi solo alla costruibilità da un valore massimo (ma in pratica può anche riferirsi alla distruzione), mentre noexcept(T(std::move(value))) si riferisce sempre sia alla costruzione che alla distruzione.

Quindi, nel tuo caso, il più risparmiare strada, evitando la questione irrisolta dei std::is_nothrow_move_constructible tratti, è quello di utilizzare nuova collocazione, evitando il problema con std::bad_alloc (menzionato nel commento di Chris Beck), e, allo stesso modo, utilizzare T ' s desctructor per il distruttore del wrapper.

template<typename T> 
class Wrapper { 
public: 
    Wrapper(T&& value) noexcept(new(nullptr) T(std::move(value))) 
     : value_(std::move(value)) 
    {} 
    ~Wrapper() noexcept(noexcept(value_.T::~T())) 
    {} 
private: 
    T value_; 
};