Uso del operador de flecha (->) en C

Estoy leyendo un libro llamado "Teach Yourself C in 21 Days" (ya aprendí Java y C #, así que me estoy moviendo a un ritmo mucho más rápido). Estaba leyendo el capítulo sobre punteros y el operador-> (flecha) apareció sin explicación. Creo que se usa para llamar a miembros y funciones (como el equivalente del operador (punto), pero para punteros en lugar de miembros). Pero no estoy completamente seguro..

¿Podría obtener una explicación y un ejemplo de código?

foo->bares equivalente a (*foo).bar, es decir, obtiene el miembro llamado bardesde la estructura que fooapunta.

Si eso es.

Es solo la versión de punto cuando desea acceder a elementos de una estructura / clase que es un puntero en lugar de una referencia.

struct foo
{
  int x;
  float y;
};

struct foo var;
struct foo* pvar;
pvar = malloc(sizeof(pvar));

var.x = 5;
(&var)->y = 14.3;
pvar->y = 22.4;
(*pvar).x = 6;

¡Eso es!

a->bes corto para (*a).btodos los sentidos (lo mismo para funciones: a->b()es corto para (*a).b())

Simplemente agregaría a las respuestas el "¿por qué?".

.es un operador de acceso de miembro estándar que tiene mayor prioridad que el *operador de puntero.

Cuando intentas acceder a las partes internas de una estructura y la escribiste como *foo.barentonces, el compilador pensaría querer un elemento 'bar' de 'foo' (que es una dirección en memoria) y obviamente esa mera dirección no tiene ningún miembro.

Por lo tanto, debe pedirle al compilador que primero desreferencia con (*foo)y luego acceda al elemento miembro: (*foo).barque es un poco torpe para escribir, por lo que la gente buena ha creado una versión abreviada: foo->barque es una especie de acceso de miembro por operador de puntero.

foo->bares solo una abreviatura de (*foo).bar. Eso es todo al respecto.

struct Node {
    int i;
    int j;
};
struct Node a, *p = &a;

Aquí el acceso a los valores de iy jque se puede utilizar la variable ay el puntero pde la siguiente manera: a.i, (*p).iy p->ison todos iguales.

Aquí .hay un "Selector directo" y ->es un "Selector indirecto".

Bueno, tengo que agregar algo también. La estructura es un poco diferente de la matriz porque la matriz es un puntero y la estructura no lo es. ¡Así que ten cuidado!

Digamos que escribo este código inútil:

#include <stdio.h>

typedef struct{
        int km;
        int kph;
        int kg;
    } car;

int main(void){

    car audi = {12000, 230, 760};
    car *ptr = &audi;

}

Aquí puntero ptr apunta a la dirección ( ! ) De la variable de estructura, audipero al lado de la estructura de la dirección también hay una porción de datos ( ! )! El primer miembro de la porción de datos tiene la misma dirección que la estructura misma y puede obtener sus datos solo haciendo referencia a un puntero como este *ptr (sin llaves) .

Pero Si desea acess cualquier otro miembro que el primero, tiene que añada un indicador como .km, .kph, .kgque no es más que compensa a la dirección base del son parte de los datos ...

Pero debido a la precedencia, no puede escribir *ptr.kgya que el operador de acceso .se evalúa antes que el operador de desreferencia *y obtendría lo *(ptr.kg)que no es posible ya que el puntero no tiene miembros. Y el compilador lo sabe y, por lo tanto, emitirá un error, por ejemplo:

error: ‘ptr’ is a pointer; did you mean to use ‘->’?
  printf("%d\n", *ptr.km);

En su lugar, usa esto (*ptr).kgy fuerza al compilador a primero desreferenciar el puntero y habilitar el acceso a la porción de datos y segundo agregar un desplazamiento (designador) para elegir el miembro.

Mira esta imagen que hice:

Pero si hubiera miembros anidados, esta sintaxis se volvería ilegible y, por ->lo tanto, se introdujo. Creo que la legibilidad es la única razón justificable para usarlo, ya que ptr->kges mucho más fácil de escribir que (*ptr).kg.

Ahora permítanos escribir esto de manera diferente para que vea la conexión más claramente. (*ptr).kg⟹ (*&audi).kg⟹ audi.kg. Aquí utilicé por primera vez el hecho de que ptres una "dirección de audi", es decir, &audiy el hecho de que "referencia" & y "desreferencia" * operadores de cancelan entre sí.

Tuve que hacer un pequeño cambio en el programa de Jack para que funcionara. Después de declarar el puntero de estructura pvar, apúntelo a la dirección de var. Encontré esta solución en la página 242 de la Programación de Stephen Kochan en C.

#include <stdio.h>

int main()
{
  struct foo
  {
    int x;
    float y;
  };

  struct foo var;
  struct foo* pvar;
  pvar = &var;

  var.x = 5;
  (&var)->y = 14.3;
  printf("%i - %.02f\n", var.x, (&var)->y);
  pvar->x = 6;
  pvar->y = 22.4;
  printf("%i - %.02f\n", pvar->x, pvar->y);
  return 0;
}

Ejecute esto en vim con el siguiente comando:

:!gcc -o var var.c && ./var

Saldrá:

5 - 14.30
6 - 22.40

#include<stdio.h>

int main()
{
    struct foo
    {
        int x;
        float y;
    } var1;
    struct foo var;
    struct foo* pvar;

    pvar = &var1;
    /* if pvar = &var; it directly 
       takes values stored in var, and if give  
       new > values like pvar->x = 6; pvar->y = 22.4; 
       it modifies the values of var  
       object..so better to give new reference. */
    var.x = 5;
    (&var)->y = 14.3;
    printf("%i - %.02f\n", var.x, (&var)->y);

    pvar->x = 6;
    pvar->y = 22.4;
    printf("%i - %.02f\n", pvar->x, pvar->y);

    return 0;
}

El ->operador hace que el código sea más legible que el *operador en algunas situaciones.

Tales como: (citado del proyecto EDK II )

typedef
EFI_STATUS
(EFIAPI *EFI_BLOCK_READ)(
  IN EFI_BLOCK_IO_PROTOCOL          *This,
  IN UINT32                         MediaId,
  IN EFI_LBA                        Lba,
  IN UINTN                          BufferSize,
  OUT VOID                          *Buffer
  );


struct _EFI_BLOCK_IO_PROTOCOL {
  ///
  /// The revision to which the block IO interface adheres. All future
  /// revisions must be backwards compatible. If a future version is not
  /// back wards compatible, it is not the same GUID.
  ///
  UINT64              Revision;
  ///
  /// Pointer to the EFI_BLOCK_IO_MEDIA data for this device.
  ///
  EFI_BLOCK_IO_MEDIA  *Media;

  EFI_BLOCK_RESET     Reset;
  EFI_BLOCK_READ      ReadBlocks;
  EFI_BLOCK_WRITE     WriteBlocks;
  EFI_BLOCK_FLUSH     FlushBlocks;

};

La _EFI_BLOCK_IO_PROTOCOLestructura contiene 4 miembros de puntero de función.

Supongamos que tiene una variable struct _EFI_BLOCK_IO_PROTOCOL * pStructy desea utilizar el *operador antiguo para llamar a su puntero de función miembro. Terminarás con un código como este:

(*pStruct).ReadBlocks(...arguments...)

Pero con el ->operador, puedes escribir así:

pStruct->ReadBlocks(...arguments...).

¿Cuál se ve mejor?

#include<stdio.h>
struct examp{
int number;
};
struct examp a,*b=&a;`enter code here`
main()
{
a.number=5;
/* a.number,b->number,(*b).number produces same output. b->number is mostly used in linked list*/
   printf("%d \n %d \n %d",a.number,b->number,(*b).number);
}

la salida es 5 5 5

Dot es un operador de desreferencia y se utiliza para conectar la variable de estructura para un registro particular de estructura. P.ej :

struct student
    {
      int s.no;
      Char name [];
      int age;
    } s1,s2;

main()
    {
      s1.name;
      s2.name;
    }

De esta manera, podemos usar un operador de puntos para acceder a la variable de estructura