Semantics de movimiento y referencias de referencias

Question

He pasado bastante tiempo implementando la semántica de movimientos para mi clase, pero ahora estoy tratando con funciones que lo usan.

Bien, entonces tengo este objeto que tiene una gran cantidad de datos en el montón: CLargeOb para el cual implementé la semántica de movimiento (constructor y operator =). Idealmente se utiliza como esto:

void OtherOb::Func(CLargeOb&& largeOb1, CLargeOb&& largeOb2) 
{ 
    SomeOtherFunc(largeOb1); // use objects 
    SomeOtherFunc(largeOb2); 
    m_largeOb1 = (CLargeOb&&)largeOb1; // save as members and trash the originals 
    m_largeOb2 = (CLargeOb&&)largeOb2; 
} 

Sin embargo, no siempre es posible permitir que los objetos se muevan/papelera, por lo que añadió estas dos funciones:

void OtherOb::Func(const CLargeOb& largeOb1, CLargeOb&& largeOb2) 
{ 
    SomeOtherFunc(largeOb1); 
    SomeOtherFunc(largeOb2); 
    m_largeOb1 = largeOb1; 
    m_largeOb2 = (CLargeOb&&)largeOb2; 
} 

void OtherOb::Func(CLargeOb&& largeOb1, const CLargeOb& largeOb2) 
{ 
    SomeOtherFunc(largeOb1); 
    SomeOtherFunc(largeOb2); 
    m_largeOb1 = (CLargeOb&&)largeOb1; 
    m_largeOb2 = largeOb2; 
} 

aunque funciona, ya se puede Supongo que se convertirá en un gran dolor en el * ss cuando tengo una función que toma 3 o más de estos objetos como parámetros ... ¿No hay una manera inteligente de resolver esto usando plantillas o tal vez 'reenvío perfecto'?

Answer 1

Como fue el caso en C++ 03, la guía es: si desea una copia, hágalo en la lista de parámetros.

De este modo, el acuerdo de llamadas con la forma de obtener el objeto, que acaba de obtener un objeto sin tener en cuenta:

void OtherOb::Func(CLargeOb largeOb1, CLargeOb largeOb2) 
{ 
    SomeOtherFunc(largeOb1); // use objects 
    SomeOtherFunc(largeOb2); 
    m_largeOb1 = std::move(largeOb1); // save as members and trash the originals 
    m_largeOb2 = std::move(largeOb2); // (you should use std::move, not cast) 
} 

La persona que llama:

OtherOb o; 

CLargeOb x, y; 
const CLargeOb z; 

o.Func(x, std::move(y)); // need x for later, done with y so move it 
o.Func(std::move(x), z); // done with x, necessarily copy z 

Esto es tan eficiente como varias sobrecargas especializados. ¿Por qué? Porque esos ya existen en la clase como constructores. Deje que el compilador averigüe a cuál llamar en el sitio de llamadas, ya sabe qué hacer.