copia explícita constructor o parámetro implícito por valor

Question

Recientemente he leído (y por desgracia recuerdo donde), que la mejor manera de escribir operador = es la siguiente:

foo &operator=(foo other) 
{ 
    swap(*this, other); 
    return *this; 
} 

en lugar de esto:

foo &operator=(const foo &other) 
{ 
    foo copy(other); 
    swap(*this, copy); 
    return *this; 
} 

La idea es que si operator = se llama con un valor r, la primera versión puede optimizar la construcción de una copia. Entonces cuando se llama con un valor r, la primera versión es más rápida y cuando se llama con un lvalue los dos son equivalentes.

Tengo curiosidad por saber qué piensan los demás acerca de esto? ¿La gente evitaría la primera versión por falta de claridad? ¿Estoy en lo correcto al decir que la primera versión puede ser mejor y que nunca puede ser peor?

Answer 1

Probablemente leerlo desde: http://cpp-next.com/archive/2009/08/want-speed-pass-by-value/

no tengo mucho que decir ya que creo que el enlace explica la lógica bastante bien. Anecdóticamente puedo confirmar que el primer formulario da como resultado menos copias en mis compilaciones con MSVC, lo que tiene sentido ya que los compiladores podrían no ser capaces de copiar elisión en el segundo formulario. Estoy de acuerdo en que la primera forma es una mejora estricta y nunca es peor que la segunda.

Editar: La primera forma puede ser un poco menos idiomática, pero no creo que esté mucho menos clara. (IMO, no es más sorprendente que ver la implementación de copiar y cambiar del operador de asignación por primera vez).

Edición n.º 2: Vaya, quise escribir copia elisión, no RVO.

Answer 2

creo que podría estar confundiendo la diferencia entre:

foo &operator=(const foo &other); y
const foo &operator=(const foo &other);

La primera forma debe ser usado para permitir: (a = b) = c;

Answer 3

estos dos son en realidad la misma. La única diferencia es donde presionas "Step In" en un depurador. Y debe saber de antemano dónde hacerlo.

Answer 4

Generalmente prefiero la segunda desde la legibilidad y el punto de vista de la "menos sorpresa"; sin embargo, reconozco que la primera puede ser más eficiente cuando el parámetro es temporal.

La primera realmente puede dar lugar a no copias, no solo una copia y es concebible que esto pueda ser una preocupación genuina en situaciones extremas.

E.g. Toma este programa de prueba. gcc -O3 -S (gcc versión 4.4.2 20091222 (Red Hat 4.4.2-20) (GCC)) genera una llamada al constructor de copias de B pero no llamadas al constructor de copias de A para la función f (el operador de asignación está en línea tanto para A como para B) A y B pueden tomarse como clases de cuerdas muy básicas. La asignación y el copiado para data se producirían en los constructores y la desasignación en el destructor.

#include <algorithm> 

class A 
{ 
public: 
    explicit A(const char*); 
    A& operator=(A val)  { swap(val); return *this; } 
    void swap(A& other)  { std::swap(data, other.data); } 
    A(const A&); 
    ~A(); 

private: 
    const char* data; 
}; 

class B 
{ 
public: 
    explicit B(const char*); 
    B& operator=(const B& val) { B tmp(val); swap(tmp); return *this; } 
    void swap(B& other)   { std::swap(data, other.data); } 
    B(const B&); 
    ~B(); 

private: 
    const char* data; 
}; 

void f(A& a, B& b) 
{ 
    a = A("Hello"); 
    b = B("World"); 
} 

Answer 5

Dada esta

foo &foo::operator=(foo other) {/*...*/ return *this;} 
foo f(); 

en código como este

foo bar; 
bar = f(); 

Podría ser más fácil para un compilador para eliminar la llamada al constructor de copia. Con RVO, podría usar la dirección del parámetro other del operador como el lugar para f() para construir su valor de retorno en.

Parece que esta optimización también es posible para el segundo caso, aunque creo que podría ser más difícil. (Especialmente cuando el operador no está en línea.)