¿Para qué se usa "->" en C y C++ al manejar estructuras de datos?

Question

¿Para qué se usa -> en C?

Ejemplo: new -> dato = dato;.

Código:

void insertar(int dato) {
    node *nuevo = (node *)malloc(sizeof(node));
    nuevo -> dato = dato;
    nuevo -> siguiente = primero;
    primero = nuevo;
}

Answer 1

Como sabemos, en C / C++ es habitual trabajar con punteros.

En el siguiente código

struct Nodo {
  int A;
  int B;
};

struct Nodo *nd = (struct Nodo *)malloc( sizeof( struct Nodo ) );

¿ Como accedemos al atributo A a través del puntero nd ?

Una de las alternativas es:

(*nd).A = 10;

Sin embaro, C / C++ nos proporcionan un método mas simple de escribir, y, personalmente, encuentro que mas simple de entender, mediante el operador ->:

nd->A = 10;

Ambos métodos son equivalentes e intercambiables. PUNTERO->ATRIBUTO es un método abreviado de hacer (*PUNTERO).ATRIBUTO.

-> es un operador, y, por lo tanto, se puede encadenar:

struct Nodo {
  struct Nodo *n;
  int A;
  int B;
};

ptr->n->A = 10;

Answer 2

Se trata de un tipo de azúcar sintáctico para el acceso a miembros de un objeto.

El operador para el acceso a miembros de un objeto es el punto (.), así pues: teniendo una instancia de un objeto cualquiera, se accede a un miembro cualquiera del mismo usando el punto:

struct Objeto {
    int Miembro;
};

Objeto a, b;
a.Miembro; // <- accede al miembro 'Miembro' de la instancia 'a'.
b.Miembro; // <- accede al miembro 'Miembro' de la instancia 'b'.

Si en lugar de una instancia tenemos un puntero a objeto, no podemos usar el operador punto, ya que un puntero no es un objeto. Sería como intentar poner en marcha un coche usando la llave sobre la matrícula: la matrícula no es un coche, aunque nos sirva para identificar un coche en concreto.

Pero si des-referenciamos el puntero con el operador unario de des-referencia (*) obtendremos la instancia del objeto y podremos usar el operador punto:

struct Objeto {
    int Miembro;
};

Objeto a;
Objeto *b = &a; // el puntero b apunta a la instancia a.
a.Miembro;    // <- accede al miembro 'Miembro' de la instancia 'a'.
(*b).Miembro; // <- des-referencia b y accede al miembro 'Miembro' de la instancia apuntada.

Pero la sintaxis (*puntero).miembro es incómoda de leer y escribir, así que se decidió usar la sintaxis flecha (->) de manera que puntero->miembro fuese equivalente a (*puntero).miembro. Ambas opciones son usables tanto en C como en C++ pero se aconseja usar el operador flecha (->) por ser más claro.

Como curiosidad, quisiera mencionar que el operador flecha (->) es sobrecargable en C++ mientras que el operador punto (.) no lo es¹.

Otros azúcares sintácticos de operadores conocidos tanto en C como en C++ serían:

• Operador de incremento (++): variable++ equivaldría a variable = variable + 1;
• Operador de operación-asignación (+=, -=, *=, /=): variable += numero equivaldría a variable = variable + numero.
• Operador de indexación ([]): arreglo[indice] equivaldría a *(arreglo + indice)

Existen otros azúcares sintácticos no relacionados con operadores, pero mencionarlos todos sería alargar innecesariamente la respuesta.

---

¹Permitir la sobrecarga del operador punto (.) fue propuesto por Bjarne Stroustrup y Gabriel Dos Reis para el estándar C++17 (documento técnico N4173) pero la propuesta ha sido pospuesta para más adelante.

Answer 3

-> se utiliza para acceder a los elementos de una estructura de datos que se tiene referenciada por un puntero o "pointer".

node *nuevo = (node *) malloc(sizeof(node));

Crea una variable del tipo puntero a node i le asigna la dirección que devuelve malloc() con el espacio necesario para un node.

nuevo->dato = dato;

Accede al elemento dato de node y le asigna el valor de dato que ha sido pasado como argumento de la función.

Answer 4

En lenguaje C, el operador -> se utiliza después de una variable de tipo puntero que apunta a una estructura de datos, para indicar a qué campo de la estructura queremos acceder.

En este caso, la variable dato es un puntero que apunta a una variable de tipo node, que tiene varios campos dentro (dato, siguiente, ...) y con

nuevo -> dato

se indica que accedemos a su campo dato.