¿Se está desaprobando el uso de std :: swap ahora que tenemos semántica de movimiento?

Question

Duplicar posible:
Move semantics == custom swap function obsolete?

Así es como std::swap se ve como en C++ 11:

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

¿Todavía tengo especializarse std::swap para mis propios tipos , o será std::swap ser tan eficiente como sea posible, siempre que mi clase defina am ove constructor y un operador de asignación de movimiento, por supuesto?

Answer 1

La especialización de std::swap ahora es opcional, pero no obsoleta. La razón es el rendimiento.

Para el código de creación de prototipos, y quizás incluso para muchos códigos de envío, std::swap será mucho más rápido. Sin embargo, si se encuentra en una situación en la que necesita buscar cada bit de su código, escribir un intercambio personalizado puede ser una gran ventaja de rendimiento.

Considere el caso en el que su clase tiene esencialmente un puntero propietario y el constructor de movimiento y la asignación de movimiento solo tienen que ocuparse de ese puntero.Contar las cargas y las tiendas de la máquina para cada miembro:

Mover constructor: 1 carga y 2 tiendas.

Asignación de movimiento: 2 cargas y 2 tiendas.

Intercambio personalizado: 2 cargas y 2 tiendas.

std::swap es 1 movimiento de construcción y 2 asignaciones de movimiento, o: 5 cargas y 6 tiendas.

Un intercambio personalizado es potencialmente aún dos o tres veces más rápido que std::swap. Aunque cada vez que intentas averiguar la velocidad de algo contando cargas y tiendas, ambos van a ser perversos rápidamente.

Nota: Al calcular el costo de su asignación de movimiento, asegúrese y tenga en cuenta que se moverá a un valor movido (en el algoritmo std::swap). Esto a menudo niega el costo de una desasignación, aunque a costa de una sucursal.

Answer 2

Eso dependerá de sus Tipos.

Lo moverá de x a z, de y a x, de z a y. Es decir, tres operaciones de copia de la representación subyacente (tal vez solo un puntero, tal vez algo más, quién sabe)

Ahora quizás pueda crear un intercambio más rápido para su tipo (xor swap truick, inline assembler, o tal vez std :: el intercambio para los tipos subyacentes es más rápido).

O tal vez también su compilador es bueno en la optimización, y esencialmente optimiza ambos casos en las mismas instrucciones (como tener el temporal en un registro).

Yo personalmente tiendo a implementar siempre una función de miembro de intercambio que se llamará desde varios lugares, incluyendo cosas como asignación de movimiento, pero YMMV.

Answer 3

Este swap() llama a un constructor de movimiento y 2 tareas de movimiento. Creo que se puede escribir más eficiente swap() por su particular tipo de clase como,

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); 
    } 
}; 

independientemente de la aplicación de movimiento constructor y operador de asignación.

Answer 4

¿Se está desaprobando el uso de std :: swap ahora que tenemos semántica de movimiento?

No. Esta es la versión genérica, pero puede optimizarla para omitir una operación de tercer movimiento. Mi preferencia es combinar la copia & idioma de intercambio con la personalización de std :: swap para mis clases.

Eso significa que tendré:

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); } 
}