C++
Copia elision

Propósito de la copia elision

Hay lugares en el estándar donde un objeto se copia o mueve para inicializar un objeto. Elección de copia (a veces llamada optimización de valor de retorno) es una optimización por la cual, bajo ciertas circunstancias específicas, se permite que un compilador evite la copia o el movimiento aunque la norma diga que debe suceder.

Considera la siguiente función:

std::string get_string()
{
  return std::string("I am a string.");
}

De acuerdo con la estricta redacción de la norma, esta función inicializará una std::string temporal, luego la copiará / moverá al objeto de valor de retorno y luego destruirá la temporal. El estándar es muy claro que así se interpreta el código.

Copy elision es una regla que permite a un compilador de C ++ ignorar la creación del temporal y su posterior copia / destrucción. Es decir, el compilador puede tomar la expresión de inicialización para el temporal e inicializar directamente el valor de retorno de la función. Esto obviamente guarda el rendimiento.

Sin embargo, tiene dos efectos visibles en el usuario:

1. El tipo debe tener el constructor de copiar / mover que se habría llamado. Incluso si el compilador evita la copia / movimiento, el tipo aún debe poder copiarse / moverse.

2. Los efectos secundarios de los constructores de copia / movimiento no están garantizados en circunstancias en las que puede producirse la elección. Considera lo siguiente:

struct my_type
{
  my_type() = default;
  my_type(const my_type &) {std::cout <<"Copying\n";}
  my_type(my_type &&) {std::cout <<"Moving\n";}
};

my_type func()
{
  return my_type();
}

Debido a que elision es una optimización, su compilador puede no ser compatible con elision en todos los casos. Y sin importar si el compilador elude un caso particular o no, el tipo todavía debe soportar la operación que se está elidiando. Por lo tanto, si se elimina una construcción de copia, el tipo aún debe tener un constructor de copia, aunque no se llamará.

Copia garantizada elision

std::mutex a_mutex;
std::lock_guard<std::mutex> get_lock()
{
  return std::lock_guard<std::mutex>(a_mutex);
}

std::lock_guard the_lock = get_lock();

std::mutex a_mutex;
std::lock_guard<std::mutex> get_lock()
{
  std::lock_guard<std::mutex> my_lock(a_mutex);
  //Do stuff
  return my_lock;
}

struct trivially_copyable {
    int a;  
};

void foo (trivially_copyable a) {}

foo(trivially_copyable{}); //copy elision not mandated

Valor de retorno elision

Si devuelve una expresión prvalue de una función, y la expresión prvalue tiene el mismo tipo que el tipo de retorno de la función, entonces se puede eliminar la copia del prvalue temporal:

std::string func()
{
  return std::string("foo");
}

Casi todos los compiladores eludirán la construcción temporal en este caso.

Parámetro elision

Cuando pasa un argumento a una función, y el argumento es una expresión prvalue del tipo de parámetro de la función, y este tipo no es una referencia, entonces la construcción del prvalue se puede eliminar.

void func(std::string str) { ... }

func(std::string("foo"));

Esto dice que para crear una string temporal, luego muévala en el parámetro de función str . Copy elision permite que esta expresión cree directamente el objeto en str , en lugar de usar un movimiento + temporal.

Esta es una optimización útil para los casos en que un constructor se declara explicit . Por ejemplo, podríamos haber escrito lo anterior como func("foo") , pero solo porque la string tiene un constructor implícito que convierte de const char* a una string . Si ese constructor fuera explicit , nos veríamos obligados a usar un temporal para llamar al constructor explicit . Copiar elision nos evita tener que hacer una copia / movimiento innecesario.

Valor de retorno con nombre elision

Si devuelve una expresión lvalue desde una función, y este valor lvalue:

• representa una variable automática local para esa función, que se destruirá después de la return
• La variable automática no es un parámetro de función.
• y el tipo de la variable es el mismo tipo que el tipo de retorno de la función

Si todos estos son el caso, entonces la copia / movimiento desde el lvalue se puede eliminar:

std::string func()
{
  std::string str("foo");
  //Do stuff
  return str;
}

Los casos más complejos son elegibles para la elección, pero cuanto más complejo sea el caso, menos probable será que el compilador realmente lo evite:

std::string func()
{
  std::string ret("foo");
  if(some_condition)
  {
    return "bar";
  }
  return ret;
}

El compilador todavía podría elidir a ret , pero las posibilidades de que lo hagan disminuyen.

Como se señaló anteriormente, elision no está permitido para los parámetros de valor.

std::string func(std::string str)
{
  str.assign("foo");
  //Do stuff
  return str; //No elision possible
}

Copia inicializacion elision

Si utiliza una expresión prvalue para copiar, inicialice una variable, y esa variable tiene el mismo tipo que la expresión prvalue, entonces la copia puede ser eliminada.

std::string str = std::string("foo");

La inicialización de la copia efectivamente transforma esto en std::string str("foo"); (hay diferencias menores).

Esto también funciona con valores de retorno:

std::string func()
{
  return std::string("foo");
}

std::string str = func();

Sin la elección de copia, esto provocaría 2 llamadas al constructor de movimientos de std::string . Copy elision permite que esto llame al constructor de movimientos 1 o cero veces, y la mayoría de los compiladores optarán por este último.