const o ref o const ref o valor como un argumento de la función de establecimiento

Constancia

class MyClass { // ... private: std::string m_parameter; // ... } 

Pasar por valor:

 void MyClass::SetParameter(std::string parameter) { m_parameter = parameter; } 

Paso por ref:

 void MyClass::SetParameter(std::string& parameter) { m_parameter = parameter; } 

Paso por const. Ref:

 void MyClass::SetParameter(const std::string& parameter) { m_parameter = parameter; } 

Paso por valor constante

 void MyClass::SetParameter(const std::string parameter) { m_parameter = parameter; } 

Pass-by-universal-ref:

 void MyClass::SetParameter(std::string&& parameter) { m_parameter = parameter; } 

Pass-by-const-universal-ref:

 void MyClass::SetParameter(const std::string&& parameter) { m_parameter = parameter; } 

¿Qué variante es la mejor (posiblemente en términos de C ++ 11 y su semántica de movimientos)?

PD. Puede que los cuerpos de las funciones sean en algunos casos incorrectos.

  1. Pase por valor: no es bueno en general, ya que se puede tomar una copia de valor. (Aunque un constructor de movimientos podría mitigar).

  2. Pase por referencia: no es bueno ya que la función podría modificar el parámetro pasado. También un temporal anónimo no puede enlazar a una referencia.

  3. Paso por referencia const : sigue siendo el mejor. Ninguna copia tomada, la función no puede modificar el parámetro, y un temporal anónimo puede vincularse a una referencia const .

  4. Pasando por las variantes de && : Actualmente no tiene sentido, ya que no hay semántica de movimiento dada la forma en que se han escrito los cuerpos de función. Si hubiera escrito std::move(m_parameter, parameter) en lugar de la asignación, esto podría ganar (3) en algunos casos, y el comstackdor elegirá mejor.

Consulte ‘C ++ efectivo’ Scott Meyers: si el miembro privado es un tipo incorporado, puede ser más eficiente pasar por valor que pasar por referencia (que normalmente se implementan como punteros en el comstackdor). Esto también es cierto para los iteradores y los objetos de función en STL que están diseñados para ser pasados ​​por valor. De lo contrario, es preferible pasar por referencia a const.