C++ 0x valore di riferimento argomento argomento deduzione

Question

Dato GMan's deliziosamente malvagio auto_cast funzione di utilità inventata here, Ho cercato di capire perché non viene compilato per me quando sto provando a auto_cast da un valore di rvalue (su MSVC 10.0).

Ecco il codice che sto usando:

template <typename T> 
class auto_cast_wrapper : boost::noncopyable 
{ 
    public: 
    template <typename R> 
    friend auto_cast_wrapper<R> auto_cast(R&& pX); 

    template <typename U> 
    operator U() const 
    { 
     return static_cast<U>(std::forward<T>(mX)); 
    } 

    private: 
    //error C2440: 'initializing': cannot convert from 'float' to 'float &&' 
    auto_cast_wrapper(T&& pX) : mX(pX) { } 

    T&& mX; 
}; 

template <typename R> 
auto_cast_wrapper<R> auto_cast(R&& pX) 
{ 
    return auto_cast_wrapper<R>(std::forward<R>(pX)); 
} 

int main() 
{ 
    int c = auto_cast(5.0f); // from an rvalue 
} 

Al meglio delle mie possibilità ho cercato di seguire il riferimento C++ 0x collasso regole e le regole di deduzione modello di argomenti delineati here, e per quanto posso dire il codice di cui sopra dovrebbe funzionare.

Ricordiamo che in pre-0x C++, non è consentito di prendere un riferimento a un riferimento: qualcosa come un & & causa un errore di compilazione. C++ 0x, invece, presenta le seguenti regole collasso riferimento:

• Un & & diventa un &
• Un & & & diventa un &
• Un & & & diventa un &
• A & & & & diventa un & &

La seconda regola è una speciale regola detrazione modello argomento per i modelli funzionali che accettano un argomento con riferimento rvalue ad un argomento di un template:

template<typename T> 
void foo(T&&); 

Qui, si applicano le seguenti regole :

1. Quando foo è chiamato su un lvalue di tipo a, allora T risolve in un & e quindi del RIFERIME nce comprime le regole sopra, il tipo di argomento diventa effettivamente A &.
2. Quando foo viene chiamato su un valore rvalore di tipo A, quindi T si risolve in A, quindi il tipo di argomento diventa A & &.

Ora, quando il mouse sopra la chiamata a auto_cast(5.0f), il tooltip visualizza correttamente il suo valore di ritorno come auto_cast_wrapper<float>. Questo senso che il compilatore ha seguito correttamente Regola 2:

Quando foo è chiamata su un rvalue di tipo A, allora T decide di A.

Quindi, dal momento che abbiamo un auto_cast_wrapper<float>, il costruttore dovrebbe istanziare per prendere un float&&. Ma il messaggio di errore sembra implicare che esso istanzia per prendere un valore float.

Ecco il messaggio di errore completo, che mostra ancora una volta che T = galleggiano correttamente ancora il T & & parametro diventa T?

main.cpp(17): error C2440: 'initializing' : cannot convert from 'float' to 'float &&' 
    You cannot bind an lvalue to an rvalue reference 
    main.cpp(17) : while compiling class template member function 'auto_cast_wrapper<T>::auto_cast_wrapper(T &&)' 
    with 
    [ 
     T=float 
    ] 
    main.cpp(33) : see reference to class template instantiation 'auto_cast_wrapper<T>' being compiled 
    with 
    [ 
     T=float 
    ] 

Qualche idea?

Answer 1

Hai dimenticato di std :: inoltrare l'argomento T & & al costruttore auto_cast_wrapper. Questo rompe la catena di inoltro. Il compilatore ora dà un avvertimento ma sembra funzionare bene.

template <typename T> 
class auto_cast_wrapper 
{ 
    public: 
    template <typename R> 
    friend auto_cast_wrapper<R> auto_cast(R&& pX); 

    template <typename U> 
    operator U() const 
    { 
     return static_cast<U>(std::forward<T>(mX)); 
    } 

    private: 
    //error C2440: 'initializing': cannot convert from 'float' to 'float &&' 
    auto_cast_wrapper(T&& pX) : mX(std::forward<T>(pX)) { } 

    auto_cast_wrapper(const auto_cast_wrapper&); 
    auto_cast_wrapper& operator=(const auto_cast_wrapper&); 

    T&& mX; 
}; 

template <typename R> 
auto_cast_wrapper<R> auto_cast(R&& pX) 
{ 
    return auto_cast_wrapper<R>(std::forward<R>(pX)); 
} 

float func() { 
    return 5.0f; 
} 

int main() 
{ 

    int c = auto_cast(func()); // from an rvalue 
    int cvar = auto_cast(5.0f); 

    std::cout << c << "\n" << cvar << "\n"; 
    std::cin.get(); 
} 

di stampare una coppia di cinque.

Answer 2

Siamo spiacenti per la pubblicazione di codice non testato. :)

DeadMG è corretto che l'argomento debba essere inoltrato. Credo che l'avviso sia falso e che MSVC abbia un bug. Considerate dalla chiamata:

auto_cast(T()); // where T is some type 

T() vivranno alla fine della piena espressione, che significa che la funzione auto_cast, costruzione s' il auto_cast_wrapper, e la conversione definita dall'utente sono tutti riferimento a un oggetto ancora valido.

(Dal momento che l'involucro non può fare altro che convertire o distruggersi, non può sopravvivere il valore che è stato passato in auto_cast.)

posso risolvere potrebbe essere quello di rendere il membro solo un T. Tuttavia, effettuerai una copia/sposta invece di lanciare direttamente l'oggetto originale. Ma forse con l'ottimizzazione del compilatore va via.

---

E no, l'inoltro non è superfluo. Mantiene la categoria del valore di ciò che stiamo convertendo automaticamente:

struct foo 
{ 
    foo(int&) { /* lvalue */ } 
    foo(int&&) { /* rvalue */ } 
}; 

int x = 5; 
foo f = auto_cast(x); // lvalue 
foo g = auto_cast(7); // rvalue 

---

E se non sbaglio l'operatore di conversione non deve essere (di certo non ha bisogno di essere) ha segnato const.

Answer 3

Il motivo per cui non viene compilato è la stessa ragione per cui questo non può essere compilato:

float rvalue() { return 5.0f } 

float&& a = rvalue(); 
float&& b = a; // error C2440: 'initializing' : cannot convert from 'float' to 'float &&' 

Come a per sé è un lvalue non può essere associato a b. Nel costruttore auto_cast_wrapper avremmo dovuto usare lo std::forward<T> sull'argomento per risolvere il problema. Si noti che possiamo semplicemente usare std::move(a) nell'esempio specifico sopra, ma questo non riguarderebbe il codice generico che dovrebbe funzionare anche con lvalues. Così il costruttore auto_cast_wrapper ora diventa:

template <typename T> 
class auto_cast_wrapper : boost::noncopyable 
{ 
    public: 
    ... 

    private: 
    auto_cast_wrapper(T&& pX) : mX(std::forward<T>(pX)) { } 

    T&& mX; 
}; 

Purtroppo sembra che adesso presenta un comportamento indefinito.Ottengo il seguente avviso:

avviso C4413: 'auto_cast_wrapper :: mX': membro di riferimento è inizializzato a una temporanea che non persistono dopo il costruttore esce

Sembra che il letterale va fuori ambito prima che l'operatore di conversione possa essere licenziato. Anche se questo potrebbe essere solo un bug del compilatore con MSVC 10.0. Da GMan's answer, la durata di un temporaneo dovrebbe rimanere attiva fino alla fine dell'espressione completa.