Qual è l'uso del qualificatore ref `const &&`?

Question

Sto scavando un po 'le qualifiche di ref, seguendo una domanda precedente.

Dato il codice di esempio riportato di seguito;

#include <iostream> 
#include <string> 
#include <utility> 

struct A { 
    std::string abc = "abc"; 
    std::string& get() & { 
    std::cout << "get() &" << std::endl; 
    return abc; 
    } 
    std::string get() && { 
    std::cout << "get() &&" << std::endl; 
    return std::move(abc); 
    } 
    std::string const& get() const & { 
    std::cout << "get() const &" << std::endl; 
    return abc; 
    } 
    std::string get() const && { 
    std::cout << "get() const &&" << std::endl; 
    return abc; 
    } 
}; 

int main() 
{ 
    A a1; 
    a1.get(); 
    const A a2{}; 
    a2.get(); 
    A().get(); 
    const A a3{}; 
    std::move(a3).get(); 
} 

e l'uscita è come ci si aspetterebbe:

get() &
get() const &
get() & &
get() const & &

Questo compila ed esegue con clang e gcc 4.9.1 (non con 4.9.0). Dal vivo sample here.

In codice generale (il campione è lì per vedere come il codice viene compilato ed eseguito).

• Quale sarebbe lo scopo della const && ref-qualificazione su un metodo essere?

Il metodo è in grado di modificare il contenuto sull'oggetto (è const), un tentativo di return std::move(abc); dal metodo const && realtà non spostare il std::string affatto. Presumibilmente vorresti essere in grado di modificare l'oggetto, poiché è un valore r e non sarà disponibile per molto tempo. Se fosse necessario rimuovere il metodo qualificato const &&, il codice std::move(a3).method() si collegherebbe al metodo qualificato const &, il che avrebbe senso.

• cosa, se del caso, sarebbe la differenza semantica implicita essere compreso tra un metodo qualificato come const & e uno qualificato come const &&? Cioè come cambierebbe l'implementazione o perché vorresti entrambi?
• Il std::string potrebbe essere "spostato" fuori dall'oggetto temporaneo?
• Che aspetto avrebbe una firma "canonica" per std::string get() const && in questo caso?

Answer 1

Sull'utilità di const&& ... (in generale)

L'utilità del qualificatore const&& nel metodo membro è minima nella migliore delle ipotesi. L'oggetto non può essere modificato nello stesso modo in cui un metodo && consente di modificarlo; dopo tutto è const (come notato, lo mutable lo cambia). Quindi non saremo in grado di strappare il suo coraggio, poiché il temporaneo sta scadendo comunque, come faremmo in qualcosa di simile a un normale move.

In molti modi l'utilità del const&& può essere meglio valutato nel contesto di quanto sia utile un oggetto di tipo const T&& è per cominciare. Quanto è utile l'argomento di una funzione? Come indicato in un'altra risposta (a questa domanda) here, sono molto utili nel dichiarare funzioni cancellate, ad es. in questo caso

template <class T> void ref (const T&&) = delete; 

per disabilitare esplicitamente oggetti di tipi e categorie prvalue valore xValue venga utilizzato con le funzioni, e const T&& fa bind to all prvalue and xvalue objects.

Qual è l'utilità del qualificatore di metodo const&&?

E 'interessante notare che nella proposta C++ library extensions, optional, § 5.3, include sovraccarichi, per esempio

constexpr T value() const &&; 

che sono qualificati come const&& e specificati per eseguire la stessa azione del && alternativa.

Il motivo per cui posso dedurre per questo caso; è che questo è per completezza e correttezza. Se il metodo value() viene richiamato su un valore rvalue, esegue la stessa azione indipendentemente dal fatto che sia const o meno. Lo const dovrà essere gestito dall'oggetto contenuto che viene spostato o dal codice client che lo utilizza. Se esiste uno stato mutable con l'oggetto contenuto, allora quello stato può essere legittimamente modificato.

Potrebbe esserci ancora qualche merito in questo; in ordine sparso ...

• di dichiararla = delete di vietare l'uso del metodo su prvalues ​​e XValues.
• Se il tipo ha stato mutabile e il qualificatore ha senso (possibilmente in aggiunta agli altri qualificatori) nell'ambiente di destinazione, considerarlo.
• Se si implementa un tipo di contenitore generico, quindi per completezza e correttezza , considerare di aggiungerlo ed eseguire la stessa azione del metodo &&. I consigli qui sono ordinati dalla libreria standard (e dalle sue estensioni).

Cosa sarebbe una firma "canonica" apparire come un metodo qualificato const&&?

Dato che il metodo sarà eseguire la stessa azione del metodo di &&, Auspico, pertanto, che la firma corrisponda alla firma &&.

Answer 2

Vedo due utilizzi principali per qualificare un metodo. Uno è come mostrato nel tuo metodo get() &&, dove lo usi per selezionare un'implementazione potenzialmente più efficiente che è disponibile solo quando sai che l'oggetto non sarà più utilizzato. Ma l'altro è un suggerimento di sicurezza per evitare di chiamare determinati metodi su oggetti temporanei.

In questi casi è possibile utilizzare la notazione come get() const && = delete, anche se realisticamente salverei questo approccio per la modifica dei metodi, in particolare quelli che sono potenzialmente costosi. Non ha molto senso mutare e quindi scartare un oggetto senza recuperare qualcosa, e doppiamente se è costoso eseguire la mutazione. Questo costrutto fornisce al compilatore un modo per contrassegnare e impedire tale utilizzo.

Answer 3

possiamo trovare una simile esplorazione di questo problema in questo articolo What are const rvalue references good for? e quello dell'uso che si è distinto sia questo esempio forma la libreria standard:

template <class T> void ref (const T&&) = delete; 
template <class T> void cref (const T&&) = delete; 

che disabilita ref e cref per rvalues ​​del tutto. Possiamo trovare queste dichiarazioni nella sezione draft C++11 standard20.8Oggetti funzionali paragrafo .

Scott Meyers allude a questo uso in Universal References in C++11:

Anche la semplice aggiunta di un qualificatore const è sufficiente per disattivare la interpretazione di “& &” come riferimento universale:

Answer 4

Supponiamo di avere un tipo con uno stato mutable. Quindi const&& ci consentiranno entrambi di mutare quello stato e indicano che tale mutazione è sicura.

struct bar; 

struct foo { 
    mutable std::vector<char> state; 
    operator bar() const&; 
    operator bar() const&&; 
}; 

const non è assoluto.

Blocco stato mutabile, non è sicuro per allontanare const in un metodo const&& per estrarre stato, poiché l'estrazione stato in tal modo da un oggetto reale const è comportamento indefinito.