¿Cuál es el uso de referencias de pasada const de tipos primitivos?

Question

En un proyecto mantengo, veo un montón de código como este para simples get / set métodos

const int & MyClass::getFoo() { return m_foo; }

void MyClass::setFoo(const int & foo) { m_foo = foo; }

¿Cuál es la razón para hacer que en lugar de lo siguiente?

int MyClass::getFoo() { return m_foo; }  // Removed 'const' and '&' 

void MyClass::setFoo(const int foo) { m_foo = foo; }  // Removed '&'

Al pasar una referencia a un tipo primitivo debe exigir el mismo (o más) que pasa esfuerzo como valor del tipo en sí, ¿verdad?
Es sólo un número después de todo ...
Se trata sólo de algunos intentos de micro-optimización o hay un verdadero beneficio?

Answer 1

La diferencia es que si usted consigue ese resultado en una referencia a sí mismo que puede realizar un seguimiento de los cambios de la variable miembro entero en su propio nombre de la variable sin recordar la función.

const &int x = myObject.getFoo();
cout<<x<<endl;
//...
cout<<x<<endl;//x might have changed

Probablemente no sea la mejor opción de diseño, y es muy peligroso para devolver una referencia (const o no), en caso de que una variable que consigue liberado de alcance se devuelve. Así que si devuelve una referencia, tenga cuidado para asegurarse de que no es una variable que se sale del ámbito.

Hay una ligera diferencia para el modificador también, pero de nuevo, probablemente no es algo que vale la pena hacerlo, o que se pretendía.

void test1(int x)
{
  cout<<x<<endl;//prints 1
}

void test2(const int &x)
{
  cout<<x<<endl;//prints 1 or something else possibly, another thread could have changed x
}

int main(int argc, char**argv)
{
  int x = 1;
  test1(x);
  //...
  test2(x);
  return 0;
}

Así, el resultado final es que se obtiene cambios incluso después de que se pasan los parámetros.

Answer 2

Para mí, hacer pasar un referencia constante de primitivas es un error. O bien tiene que modificar el valor, y en ese caso se pasa un referencia no const , o simplemente necesita para acceder al valor y en ese caso se pasa un const .

referencias Const debe ser utilizado para las clases complejas, cuando los objetos de copia podría ser un problema de rendimiento. En el caso de primitivas, a menos que necesite modificar el valor de la variable no se debe aprobar un referencia . La razón es que referencias tomar más tiempo de cálculo que no referencias , ya que con referencias , el programa tiene que mirar hacia arriba en una mesa para encontrar dirección del objeto. Cuando este tiempo de búsqueda es más corto que el tiempo de copia, las referencias son una mejora.

En general, enteros y direcciones tener la misma longitud de bytes en las implementaciones de bajo nivel. Por lo que el momento de la copia de un int como valor de retorno de una función es equivalente al tiempo de la copia de un Dirección . Pero en el caso en que un int se devuelve, no se realiza ninguna mirada hacia arriba, por lo tanto, el rendimiento se incrementa.

Answer 3

La principal diferencia entre devolver un valor y devolver una referencia constante es que usted puede entonces const_cast esa referencia y alterar el valor.

Es un ejemplo de mal diseño y un intento de crear un diseño inteligente donde el diseño fácil y concisa sería más que suficiente. En lugar de devolver un valor que el autor hace que los lectores de código de pensar cuál es la intención que podría haber tenido.

Answer 4

No hay mucho beneficio. He visto esto en marco o macro generada captadores y definidores antes. El código de macro no distingue entre tipos primitivos y no POD y acaba de utilizar const type& en todos los ámbitos para los emisores. Dudo que se trata de una cuestión de eficiencia o un malentendido genuino; lo más probable es que esto es un problema de consistencia.

Answer 5

Creo que este tipo de código está escrito que han entendido mal el concepto de referencias y utilizarlo para todo, incluyendo los tipos de datos primitivos. También he visto algo de código como este y no puedo ver ninguna ventaja de hacer esto.

Answer 6

No hay ningún punto y se benefician excepto

void MyClass::setFoo(const int foo)
void MyClass::setFoo(const int& foo)

como entonces no será capaz de volver a utilizar la aplicación en el interior de la variable 'foo' 'setFoo'. Y yo creo que 'int &' es sólo porque individuo simplemente acostumbrarse a pasar todas las cosas con referencia constante y no hay nada malo en ello.