C++ auto con più scelte

Question

Durante le mie avventure con il progetto mi sono reso conto che non posso usare il vantaggio della nuova parola chiave auto C++ 11 se voglio inizializzare il parametro a seconda della condizione.

Fondamentalmente ho avuto un frammento di codice come questo:

auto foo = bar::getfoo(); 

che doveva essere il cambiamento a:

FOO foo 
if(cond){ 
    foo = bar::getfoo(); 
} else { 
    foo = baz::getotherfoo(); 
} 

Ma poi ho bisogno di dichiarare la foo con il tipo (come il compilatore può So che userò lo stesso tipo di ritorno Mi stavo chiedendo se c'è un modo di usare la parola chiave auto in questo caso .. L'altra soluzione che ho trovato utilizza l'operatore?: con tale codice:

auto foo = cond ? bar::getfoo() : baz::getotherfoo(); 

Ma se ci sono più di due funzioni tra cui scegliere non desidero concatenare il? : operatori. Mi chiedo se ci sia qualche schema valido da utilizzare in questo caso.

Answer 1

tuo istinto per utilizzare la? : gli operatori sono corretti - è una buona idea inizializzare una variabile solo una volta ed evitare il ciclo ridondante di costruzione/assegnazione predefinito.

Un modo per farlo è di rinviare la selezione della creazione Foo ad una piccola funzione di utilità:

auto make_foo() -> decltype(bar::getfoo()) 
{ 
    if (condition1()) { 
     return bar::getfoo(); 
    } 
    else if(condition2()) { 
     return baz::getfoo(); 
    } 
    else { 
     return banana::getfoo(); 
    } 
} 

void foo_test() { 

    auto foo = make_foo(); 
} 

Nota che a causa di Return Value Optimization, questo è estremamente efficiente.

Se si dispone di C++ 14 è ancora più bello - il make_foo() può dedurre il proprio tipo di ritorno:

auto make_foo() { 
    if (condition1()) { 
     return bar::getfoo(); 
    } 
    else if(condition2()) { 
     return baz::getfoo(); 
    } 
    else { 
     return banana::getfoo(); 
    } 
} 

Answer 2

Questo è ciò che è decltype. Esso vi fornirà il tipo di espressione, senza in realtà la valutazione (e si potrebbe implementare in termini di auto off):

decltype(bar::getfoo()) foo; 
if (....) {foo = ...;} else {foo = ...;} 

Answer 3

auto a = foo(); 

costrutti a da foo();

std::decay<decltype(foo())>::type a; 
if(cond){ 
    a = foo(); 
}else{ 
    a = bar(); 
} 

predefinita costruisce a poi assegna ad essa il risultato di foo() o bar() sulla base di cond.

decay è necessario in quanto in caso contrario di foo() restituisce un riferimento o un const decltype sarà dedurre il tipo di 'sbagliato' per a.

auto a = [&]{ 
    if (cond) 
    return foo(); 
    else 
    return bar(); 
}(); 

utilizza una funzione C++ 14 (che la maggior parte C++ 11 compilatori supportati nella fase iniziale), ma condizionatamente chiamate sia foo o bar e costruisce a da esso. Questo logico richiede una mossa in più, ma il compilatore quasi sicuramente lo eliderà, quindi non accadrà.