C++ diferencia entre ** y * & en el parámetro que pasa

Question

He implementado operaciones en una lista, una de ellas es agregar, y como no deseo devolver nada, leí que tenía que usar **, y funciona, pero he visto en otro lugar que se pasa como * &, pero no sé la diferencia

addNode (nodo * & cabeza, int value) addNode (nodo ** cabeza, int value)

¿Cuál es la diferencia, y cuál es mejor, o significan lo mismo? Sé que el segundo es un puntero a un puntero.

Gracias

Answer 1

Esta es la diferencia entre pass by value y pass by reference. Pase por referencia; básicamente, implícitamente hace la referencia y la desreferencia que le proporciona el doble puntero.

Answer 2

El primero (**) es un puntero a un puntero y la segunda (*&) es una referencia a un puntero.

Una referencia y un puntero son conceptualmente bastante similares. Pero hay algunas diferencias importantes, por ejemplo:

• Una referencia no puede ser NULL (pero puede referirse a un puntero que apunta a NULL).
• No puede modificar una referencia para hacer referencia a otra cosa.
• Necesita desreferenciar un puntero para acceder al valor.

Ver esta pregunta relacionada para más diferencias:

• Difference between pointer variable and reference variable in C++

Answer 3

Con:

addNode(node *&head, int value) 

... el tipo de head es "referencia a puntero a -nodo".

Con:

addNode(node **head, int value) 

... el tipo es "puntero a puntero a nodo".

Un puntero y una referencia son no lo mismo. Una forma simple de pensar en una referencia es como un apuntador sin referencias.

Usted tendría sintaxis diferente para llamar a las dos versiones:

node* my_node = 0; 
addNode(my_node, 0); // syntax for first version 
addNode(&my_node, 0); // syntax for 2nd version 

Existen diferencias semánticas también. Cuando pasa un puntero, puede pasar NULL. Cuando pasas una referencia, no puedes.Esta es una función que toma un ref-a-ptr confunde el asunto un poco, por lo que vamos a cambiar el problema un poco:

void make_string(string& str_ref) 
{ 
    str_ref = "my str"; 
} 

void make_string_again(string* str_ptr) 
{ 
    *str_ptr = "my other string"; 
} 

Estos dos finctions hacen lo mismo, pero se toma una referencia string mientras que el otro toma un puntero string. Si se va a hacer esto:

string str; 
make_string(str); // OK 
make_string_again(&str); // OK - &str is a pointer to a real string 
make_string_again(0); // Not OK - compiles but will crash when function dereferences the null pointer 

se puede ver que se hace difícil (pero no imposible) para llamar make_string con un puntero nulo. Esto podría ayudarlo a implementar mejores funciones en caso de que espere que make_string se nunca se llame a con un objeto no válido.