Sta specializzando std :: swap deprecato ora che abbiamo spostato la semantica?

Question

Eventuali duplicati:
Move semantics == custom swap function obsolete?

Questo è il modo std::swap si presenta come in C++ 11:

template<typename T> 
void swap(T& x, T& y) 
{ 
    T z = std::move(x); 
    x = std::move(y); 
    y = std::move(z); 
} 

Devo ancora specializzarsi std::swap per i miei tipi , o sarà std::swap essere efficiente come si ottiene, a condizione che la mia classe definisce dove costruttore e un operatore di assegnazione del movimento, ovviamente?

Answer 1

La specializzazione di std::swap è ora facoltativa, ma non deprecato. La logica è la prestazione.

Per il codice di prototipazione, e forse anche per molto codice di spedizione, std::swap sarà molto veloce. Tuttavia, se ti trovi in ​​una situazione in cui hai bisogno di trarre il massimo dal tuo codice, scrivere uno scambio personalizzato può comunque rappresentare un notevole vantaggio in termini di prestazioni.

Considerare il caso in cui la classe ha essenzialmente un puntatore proprietario e il costruttore di movimento e l'assegnazione di spostamento devono semplicemente occuparsi di quel puntatore.Conta carichi e depositi per ogni membro:

Costruttore di spostamento: 1 carico e 2 negozi.

Spostamento assegnazione: 2 carichi e 2 negozi.

Swap personalizzato: 2 carichi e 2 negozi.

std::swap è una costruzione di spostamento e due spostamenti, oppure: 5 carichi e 6 negozi.

Uno scambio personalizzato è potenzialmente ancora due o tre volte più veloce di std::swap. Anche se in qualsiasi momento stai cercando di capire la velocità di qualcosa contando carichi e negozi, entrambi saranno presto malvagi.

Nota: nel calcolo del costo dell'assegnazione del movimento, accertarsi che si passi al valore spostato da (nell'algoritmo std::swap). Questo spesso nega il costo di una deallocazione, anche se a costo di una filiale.

Answer 2

Dipende dai tipi.

Lo si sposta da x a z, da y a x, da z a y. Ecco tre operazioni di copia della rappresentazione sottostante (forse solo un puntatore, forse qualcosa di più, chissà)

Ora forse puoi creare uno scambio più veloce per il tuo tipo (xor swap trick, inline assembler o forse std :: scambiare per i tuoi tipi sottostanti è solo più veloce).

O forse anche il compilatore è in grado di ottimizzare e in sostanza ottimizza entrambi i casi nelle stesse istruzioni (come il temporaneo in un registro).

Personalmente tendo ad implementare sempre una funzione membro di scambio che verrà chiamata da più punti, comprese le cose come l'assegnazione del movimento, ma YMMV.

Answer 3

Questo swap() chiama un costruttore di trasloco e 2 assegnazioni di spostamento. Penso che si può scrivere più efficiente swap() per il suo particolare tipo di classe come,

class X 
{ 
    int * ptr_to_huge_array; 
public: 
// ctors, assgn ops. etc. etc. 

    friend void swap(X& a, X& b) 
    { 
     using std::swap; 
     swap(a.ptr_to_huge_array, b.ptr_to_huge_array); 
    } 
}; 

indipendentemente l'attuazione di movimento costruttore e operatore di assegnazione.

Answer 4

è specializzata std :: scambio deprecato ora che abbiamo la semantica mossa?

No. Questa è la versione generica, ma è possibile ottimizzarla per saltare una terza operazione di spostamento. La mia preferenza è quella di combinare copia dello swap idioma & con la personalizzazione di std :: swap per le mie classi.

Ciò significa che avrò:

class Aaaa 
{ 
public: 
    Aaaa(); // not interesting; defined elsewhere 
    Aaaa(Aaaa&& rvalueRef); // same 
    Aaaa(const Aaaa& ref); // same 
    ~Aaaa(); // same 
    Aaaa& operator=(Aaaa object) // copy&swap 
    { 
     swap(object); 
     return *this; 
    } 
    void swap(Aaaa& other) 
    { 
     std::swap(dataMember1, other.dataMember1); 
     std::swap(dataMember2, other.dataMember2); 
     // ... 
    } 

    // ... 
}; 

namespace std 
{ 
    template<> inline void std::swap(Aaaa& left, Aaaa& right) 
    { left.swap(right); } 
}