¿Hay beneficios de pasar por puntero sobre pasar por referencia en C ++?

¿Cuáles son los beneficios de pasar por puntero sobre pasar por referencia en C ++?

Últimamente, he visto una serie de ejemplos que eligieron pasar argumentos de función por punteros en lugar de pasar por referencia. ¿Hay beneficios al hacer esto?

Ejemplo:

func(SPRITE *x);

con una llamada de

func(&mySprite);

vs.

func(SPRITE &x);

con una llamada de

func(mySprite);

Un puntero puede recibir un parámetro NULL, un parámetro de referencia no. Si alguna vez existe la posibilidad de que desee pasar "sin objeto", utilice un puntero en lugar de una referencia.

Además, pasar por puntero le permite ver explícitamente en el sitio de la llamada si el objeto se pasa por valor o por referencia:

// Is mySprite passed by value or by reference?  You can't tell 
// without looking at the definition of func()
func(mySprite);

// func2 passes "by pointer" - no need to look up function definition
func2(&mySprite);

Pasando por puntero

• La persona que llama tiene que tomar la dirección -> no transparente
• Se puede proporcionar un valor 0 para significar nothing. Esto se puede usar para proporcionar argumentos opcionales.

Pase por referencia

• La persona que llama solo pasa el objeto -> transparente. Tiene que usarse para la sobrecarga del operador, ya que la sobrecarga para los tipos de puntero no es posible (los punteros son tipos incorporados). Entonces no puedes string s = &str1 + &str2;usar punteros.
• No hay valores 0 posibles -> La función llamada no tiene que verificarlos
• La referencia a const también acepta temporales: los void f(const T& t); ... f(T(a, b, c));punteros no pueden usarse así, ya que no puede tomar la dirección de un temporal.
• Por último, pero no menos importante, las referencias son más fáciles de usar -> menos posibilidades de errores.

Me gusta el razonamiento de un artículo de "cplusplus.com:"

1. Pase por valor cuando la función no quiera modificar el parámetro y el valor sea fácil de copiar (ints, doubles, char, bool, etc ... tipos simples. Std :: string, std :: vector y todos los demás STL Los contenedores NO son tipos simples).

2. Pase por el puntero constante cuando el valor es costoso de copiar Y la función no desea modificar el valor señalado Y NULO es un valor válido esperado que maneja la función.

3. Pase por un puntero no constante cuando el valor es costoso de copiar Y la función quiere modificar el valor señalado Y NULL es un valor válido y esperado que maneja la función.

4. Pase por referencia constante cuando el valor es costoso de copiar Y la función no quiere modificar el valor al que se hace referencia AND NULL no sería un valor válido si se utilizara un puntero.

5. Pase por referencia no cont cuando el valor es costoso de copiar Y la función quiere modificar el valor al que se hace referencia AND NULL no sería un valor válido si se utilizara un puntero.

6. Al escribir funciones de plantilla, no hay una respuesta clara porque hay algunas compensaciones a considerar que están más allá del alcance de esta discusión, pero es suficiente decir que la mayoría de las funciones de plantilla toman sus parámetros por valor o referencia (constante) , sin embargo, debido a que la sintaxis del iterador es similar a la de los punteros (asterisco para "desreferenciar"), cualquier función de plantilla que espere iteradores como argumentos también aceptará de manera predeterminada los punteros (y no comprobará NULL ya que el concepto de iterador NULL tiene una sintaxis diferente )

http://www.cplusplus.com/articles/z6vU7k9E/

Lo que deduzco de esto es que la principal diferencia entre elegir usar un puntero o un parámetro de referencia es si NULL es un valor aceptable. Eso es.

Si el valor es input, output, modificable, etc., debe estar en la documentación / comentarios sobre la función, después de todo.

"Suficiente cuerda para pegarse un tiro en el pie" de Allen Holub enumera las siguientes 2 reglas:

120. Reference arguments should always be `const`
121. Never use references as outputs, use pointers

Enumera varias razones por las que se agregaron referencias a C ++:

• son necesarios para definir constructores de copia
• son necesarios para sobrecargas del operador
• const las referencias le permiten tener una semántica de paso por valor mientras evita una copia

Su punto principal es que las referencias no deben usarse como parámetros de 'salida' porque en el sitio de la llamada no hay indicación de si el parámetro es una referencia o un parámetro de valor. Entonces su regla es usar solo constreferencias como argumentos.

Personalmente, creo que esta es una buena regla general, ya que deja más claro cuándo un parámetro es un parámetro de salida o no. Sin embargo, aunque personalmente estoy de acuerdo con esto en general, me dejo influenciar por las opiniones de otros en mi equipo si ellos defienden los parámetros de salida como referencias (a algunos desarrolladores les gustan inmensamente).

Aclaraciones a las publicaciones anteriores:

Las referencias NO son una garantía de obtener un puntero no nulo. (Aunque a menudo los tratamos como tales).

Si bien es un código horriblemente malo, como en el caso de llevarlo detrás del código incorrecto de la leñera , lo siguiente se compilará y ejecutará: (al menos en mi compilador).

bool test( int & a)
{
  return (&a) == (int *) NULL;
}

int
main()
{
  int * i = (int *)NULL;
  cout << ( test(*i) ) << endl;
};

El verdadero problema que tengo con las referencias radica en otros programadores, en adelante denominados IDIOTS , que asignan en el constructor, desasignan en el destructor y no proporcionan un constructor de copia u operador = ().

De repente hay un mundo de diferencia entre foo (BAR bar) y foo (BAR & bar) . (Se invoca la operación automática de copia a nivel de bit. La desasignación en el destructor se invoca dos veces).

Afortunadamente, los compiladores modernos recogerán esta doble desasignación del mismo puntero. Hace 15 años, no lo hicieron. (En gcc / g ++, use setenv MALLOC_CHECK_ 0 para volver a visitar las formas anteriores). Como resultado de DEC UNIX, la misma memoria se asigna a dos objetos diferentes. Mucha diversión de depuración allí ...

Más prácticamente:

• Las referencias ocultan que está cambiando los datos almacenados en otro lugar.
• Es fácil confundir una referencia con un objeto copiado.
• Los punteros lo hacen obvio!

La mayoría de las respuestas aquí no abordan la ambigüedad inherente de tener un puntero en bruto en una firma de función, en términos de expresar intención. Los problemas son los siguientes:

• La persona que llama no sabe si el puntero apunta a un solo objeto o al inicio de una "matriz" de objetos.

• La persona que llama no sabe si el puntero "posee" la memoria a la que apunta. IE, si la función debe liberar memoria o no. ( foo(new int)- ¿Es esto una pérdida de memoria?).

• La persona que llama no sabe si se nullptrpuede pasar de forma segura a la función.

Todos estos problemas se resuelven mediante referencias:

• Las referencias siempre se refieren a un solo objeto.

• Las referencias nunca poseen la memoria a la que se refieren, son simplemente una vista a la memoria.

• Las referencias no pueden ser nulas.

Esto hace que las referencias sean un candidato mucho mejor para uso general. Sin embargo, las referencias no son perfectas, hay un par de problemas importantes a considerar.

• Sin indirección explícita. Esto no es un problema con un puntero sin formato, ya que tenemos que usar el &operador para mostrar que de hecho estamos pasando un puntero. Por ejemplo, int a = 5; foo(a);aquí no está nada claro que se esté pasando a por referencia y se pueda modificar.
• Nulabilidad Esta debilidad de los punteros también puede ser una fortaleza, cuando realmente queremos que nuestras referencias sean anulables. Al ver que std::optional<T&>no es válido (por buenas razones), los punteros nos dan esa nulabilidad que desea.

Entonces, parece que cuando queremos una referencia anulable con indirección explícita, ¿debemos alcanzar un T*derecho? ¡Incorrecto!

Abstracciones

En nuestra desesperación por la nulabilidad, podemos alcanzar T*y simplemente ignorar todas las deficiencias y la ambigüedad semántica enumeradas anteriormente. En cambio, deberíamos buscar lo que C ++ hace mejor: una abstracción. Si simplemente escribimos una clase que envuelve un puntero, obtenemos la expresividad, así como la nulabilidad y la indirección explícita.

template <typename T>
struct optional_ref {
  optional_ref() : ptr(nullptr) {}
  optional_ref(T* t) : ptr(t) {}
  optional_ref(std::nullptr_t) : ptr(nullptr) {}

  T& get() const {
    return *ptr;
  }

  explicit operator bool() const {
    return bool(ptr);
  }

private:
  T* ptr;
};

Esta es la interfaz más simple que se me ocurrió, pero hace el trabajo de manera efectiva. Permite inicializar la referencia, verificar si existe un valor y acceder al valor. Podemos usarlo así:

void foo(optional_ref<int> x) {
  if (x) {
    auto y = x.get();
    // use y here
  }
}

int x = 5;
foo(&x); // explicit indirection here
foo(nullptr); // nullability

¡Hemos logrado nuestros objetivos! Veamos ahora los beneficios, en comparación con el puntero sin formato.

• La interfaz muestra claramente que la referencia solo debe referirse a un objeto.
• Claramente, no posee la memoria a la que se refiere, ya que no tiene un destructor definido por el usuario y ningún método para eliminar la memoria.
• La persona que llama sabe que nullptrse puede transmitir, ya que el autor de la función solicita explícitamente unoptional_ref

Podríamos hacer que la interfaz sea más compleja desde aquí, como agregar operadores de igualdad, una monádica get_ory una mapinterfaz, un método que obtiene el valor o arroja una excepción, constexprsoporte. Eso lo puedes hacer tú.

En conclusión, en lugar de usar punteros sin procesar, razone sobre lo que esos punteros realmente significan en su código, y aproveche una abstracción de biblioteca estándar o escriba la suya propia. Esto mejorará su código significativamente.

Realmente no. Internamente, el paso por referencia se realiza esencialmente pasando la dirección del objeto referenciado. Por lo tanto, realmente no hay ganancias de eficiencia al pasar un puntero.

Sin embargo, pasar por referencia tiene un beneficio. Se garantiza que tendrá una instancia de cualquier objeto / tipo que se esté pasando. Si pasa un puntero, corre el riesgo de recibir un puntero NULL. Al usar el paso por referencia, está empujando una comprobación NULL implícita de un nivel a la persona que llama de su función.