C ++ auto e vs auto

Quando si creano variabili locali, è corretto usare (const) auto&o auto?

per esempio:

SomeClass object;
const auto result = object.SomeMethod();

o const auto& result = object.SomeMethod();

Dove SomeMethod () restituisce un valore non primitivo, forse un altro tipo definito dall'utente. La mia comprensione è che const auto& resultè corretto poiché il risultato restituito da SomeMethod () chiamerebbe il costruttore di copia per il tipo restituito. Perfavore, correggimi se sbaglio.

E per i tipi primitivi? Presumo const auto sum = 1 + 2;sia corretto.

Questo vale anche per i loop basati su intervallo?

for(const auto& object : objects)

autoe auto &&coprono la maggior parte dei casi:

• Utilizzare autoquando è necessaria una copia locale. Questo non produrrà mai un riferimento. Il costruttore di copia (o spostamento) deve esistere, ma potrebbe non essere chiamato, a causa dell'ottimizzazione dell'elisione della copia .

• Usalo auto &&quando non ti interessa se l'oggetto è locale o meno. Tecnicamente, questo produrrà sempre un riferimento, ma se l'inizializzatore è temporaneo (ad esempio, la funzione restituisce per valore), si comporterà essenzialmente come il tuo oggetto locale.

  Inoltre, auto &&non garantisce nemmeno che l'oggetto sarà modificabile. Dato un constoggetto o un riferimento, dedurrà const. Tuttavia, si presume spesso la modificabilità, dato il contesto specifico.

auto &e auto const &sono un po 'più specifici:

• auto &garantisce che stai condividendo la variabile con qualcos'altro. È sempre un riferimento e mai temporaneo.

• auto const &è simile auto &&, ma fornisce l'accesso in sola lettura.

E per i tipi primitivi / non primitivi?

Non c'è differenza.

Questo vale anche per i loop basati su intervallo?

Sì. Applicando i principi di cui sopra,

• Utilizzare auto &&per la capacità di modificare e scartare i valori della sequenza all'interno del ciclo. (Cioè, a meno che il contenitore non fornisca una visualizzazione di sola lettura, ad esempio std::initializer_list, nel qual caso sarà effettivamente una auto const &.)
• Utilizzare auto &per modificare i valori della sequenza in modo significativo.
• Utilizzare auto const &per l'accesso in sola lettura.
• Da utilizzare autoper lavorare con copie (modificabili).

Parli anche auto constsenza riferimenti. Funziona, ma non è molto comunemente usato perché raramente c'è un vantaggio nell'accesso in sola lettura a qualcosa che già possiedi.

Sì, è corretto usare autoe auto&per le variabili locali. Quando si ottiene il tipo restituito di una funzione, è anche corretto da usare auto&. Questo vale anche per i loop basati su intervallo.

Le regole generali per l'utilizzo autosono:

• Scegli auto xquando vuoi lavorare con le copie.
• Scegli auto &xquando vuoi lavorare con gli elementi originali e puoi modificarli.
• Scegli auto const &xquando vuoi lavorare con gli elementi originali e non li modificherai.

Puoi leggere di più sullo specificatore automatico qui .

autoutilizza lo stesso meccanismo di deduzione del tipo dei modelli, l'unica eccezione di cui sono a conoscenza è quella delle liste di parentesi graffe, che vengono dedotte da autoas std::initializer_list, ma non dedotte in un contesto di modello.

auto x = expression;

funziona eliminando prima tutti i qualificatori di riferimento e cv dal tipo dell'espressione a destra, quindi facendo corrispondere il tipo. Per esempio, se avete const int& f(){...}quindi auto x = f();deduce xcome int, e non const int& .

L'altra forma,

auto& x = expression

non rimuove i qualificatori cv, quindi, usando l'esempio sopra, auto& x = f()deduce xcome const int&. Le altre combinazioni aggiungono semplicemente qualificatori cv.

Se vuoi che il tuo tipo sia sempre dedotto con qualificatori cv-ref, usa il famigerato decltype(auto)C ++ 14, che usa le decltyperegole di deduzione del tipo.

Quindi, in poche parole, se vuoi copie, usa auto, se vuoi riferimenti, usa auto&. Usalo constogni volta che vuoi essere aggiuntivo const.

EDIT C'è un caso d'uso aggiuntivo,

auto&& x = expression;

che utilizza le regole di compressione dei riferimenti, come nel caso dell'inoltro dei riferimenti nel codice del modello. Se expressionè un lvalue, allora xè un riferimento lvalue con i qualificatori cv di expression. Se expressionè un rvalue, allora xè un riferimento rvalue.

Quando si creano variabili locali, è corretto usare (const) auto & o auto?

Sì. L'auto non è altro che un tipo dedotto dal compilatore, quindi usa i riferimenti dove normalmente useresti i riferimenti e le copie locali (automatiche) dove normalmente useresti le copie locali. L'utilizzo o meno di un riferimento è indipendente dalla detrazione del tipo.

Dove SomeMethod () restituisce un valore non primitivo, forse un altro tipo definito dall'utente. La mia comprensione è che const auto & result è corretto poiché il risultato restituito da SomeMethod () chiamerebbe il costruttore di copia per il tipo restituito. Perfavore, correggimi se sbaglio.

Legale? Sì, con il const. La migliore pratica? Probabilmente no, no. Almeno, non con C ++ 11. Soprattutto no, se il valore restituito da SomeMethod () è già temporaneo. Ti consigliamo di conoscere la semantica di spostamento C ++ 11, l'elisione della copia e l'ottimizzazione del valore restituito: https://juanchopanzacpp.wordpress.com/2014/05/11/want-speed-dont-always-pass-by- valore/

http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=199

https://isocpp.org/wiki/faq/ctors#return-by-value-optimization

E per i tipi primitivi? Assumo const auto sum = 1 + 2; è corretta.

Sì, va bene.

Questo vale anche per i loop basati su intervallo?

for (const auto & object: objects)

Sì, anche questo va bene. Scrivo questo tipo di codice al lavoro tutto il tempo.