Quali sono i "riferimenti rvalue per * questo" per?

Question

Quali sono i casi di utilizzo più comuni di "riferimenti rvalue per * questo" che lo standard chiama anche qualificatori di riferimento per le funzioni membro?

A proposito, c'è una spiegazione molto buona su questa funzione lingua here.

Answer 1

Quando chiamato, ogni funzione membro ha un parametro oggetto implicito che fa riferimento a *this.

Quindi (a) queste normali sovraccarichi di funzioni:

void f(const T&); 
void f(T&&); 

quando viene chiamato come f(x); e (b) questi funzione membro sovraccarica:

struct C 
{ 
    void f() const &; 
    void f() &&; 
}; 

quando viene chiamato come x.f() - sia (a) e (b) la spedizione con la vitalità simile e la classifica.

Quindi i casi d'uso sono essenzialmente gli stessi. Devono supportare lo spostamento dell'ottimizzazione semantica. Nella funzione di membro rvalue potete essenzialmente saccheggiare le risorse oggetti perché si sa che è un oggetto in scadenza (sta per essere cancellato):

int main() 
{ 
    C c; 
    c.f(); // lvalue, so calls lvalue-reference member f 
    C().f(); // temporary is prvalue, so called rvalue-reference member f 
    move(c).f(); // move changes c to xvalue, so again calls rvalue-reference member f 
} 

Così, per esempio:

struct C 
{ 
    C operator+(const C& that) const & 
    { 
     C c(*this); // take a copy of this 
     c += that; 
     return c; 
    } 

    C operator+(const C& that) && 
    { 
     (*this) += that; 
     return move(*this); // moving this is ok here 
    } 
} 

Answer 2

Alcune operazioni possono essere più efficiente quando viene chiamato su rvalue, quindi sovraccaricare la categoria di valore di *this consente di utilizzare automaticamente l'implementazione più efficiente, ad es.

struct Buffer 
{ 
    std::string m_data; 
public: 
    std::string str() const& { return m_data; }  // copies data 
    std::string str()&& { return std::move(m_data); } // moves data 
}; 

(Questa ottimizzazione potrebbe essere fatto per std::ostringstream, ma non è stato formalmente proposto per quanto ne so.)

Alcune operazioni non hanno senso per chiamare il rvalues, così sovraccarico sul *this permette al modulo rvalue da eliminare:

struct Foo 
{ 
    void mutate()&; 
    void mutate()&& = delete; 
}; 

non ho effettivamente bisogno di utilizzare questa funzione ancora, ma forse troverete più usi per ora che i due compilatori mi preoccupano sostegno esso.

Answer 3

Nel mio framework del compilatore (che verrà rilasciato Sometime Soon ™), si passano voci di informazioni come token in un oggetto del compilatore, quindi si chiama finalize per indicare la fine del flusso.

Sarebbe male distruggere un oggetto senza chiamare finalize, perché non svuoterebbe tutto il suo output. Tuttavia, il distruttore non può eseguire finalize, perché può generare un'eccezione e allo stesso modo è errato chiedere finalize per altri output se il parser è già in fase di interruzione.

Nel caso in cui tutti gli input siano già incapsulati da un altro oggetto, è piacevole passare l'input a un oggetto del compilatore rvalue.

pile< lexer, parser >(output_handler).pass(open_file("source.q")); 

Senza un sostegno speciale, questo deve essere corretto perché finalize non è sempre chiamato. L'interfaccia non dovrebbe permettere all'utente di fare una cosa del genere.

La prima cosa da fare è escludere il caso in cui finalize non viene mai chiamato. L'esempio precedente è annullato se il prototipo è regolata con un lvalue ref-qualificazione come questo:

void pass(input_file f) & { 
    process_the_file(); 
} 

Questo rende spazio per aggiungere un altro sovraccarico che finalizza correttamente l'oggetto. È abilitato per il rinnovo del valore, quindi viene selezionato solo se chiamato su un oggetto che sta scadendo.

void pass(input_file f) && { 
    pass(std::move(f)); // dispatch to lvalue case 
    finalize(); 
} 

Ora l'utente quasi mai bisogno di preoccuparsi di ricordarsi di chiamare finalize, poiché la maggior parte degli oggetti del compilatore sono in ultima analisi istanziati come provvisori.

---

Nota, questo genere di cose non è specifico per i membri qualificati. Qualsiasi funzione può avere sovraccarichi separati per t & e t &&. Il modo in cui pass è in realtà attualmente implementata utilizza l'inoltro perfetto e poi fa marcia indietro per determinare la semantica corretta:

template< typename compiler, typename arg > 
void pass(compiler && c, arg a) { 
    c.take_input(a); 

    if (! std::is_reference<compiler>::value) { 
     c.finalize(); 
    } 
} 

Ci sono molti modi per affrontare il sovraccarico. In realtà, le funzioni dei membri non qualificate sono inusuali in non e si preoccupano della categoria (lvalue o rvalue) dell'oggetto su cui sono chiamate e non passano tali informazioni nella funzione. Qualsiasi parametro di funzione oltre l'implicito this deve dire qualcosa sulla categoria del suo argomento.