Wykorzystanie operatora strzałek (->) w C

Czytam książkę zatytułowaną „Naucz się C w 21 dni” (już nauczyłem się Java i C #, więc poruszam się w znacznie szybszym tempie). Czytałem rozdział na temat wskaźników i operator-> (strzałka) pojawił się bez wyjaśnienia. Myślę, że służy do wywoływania członków i funkcji (jak odpowiednik operatora (kropka), ale dla wskaźników zamiast członków). Ale nie jestem do końca pewien..

Czy mogę prosić o wyjaśnienie i próbkę kodu?

foo->barjest równoważne (*foo).bar, tzn. pobiera członka wywołanego barze struktury, która foowskazuje.

Tak, to jest to.

Jest to wersja kropkowa, gdy chcesz uzyskać dostęp do elementów struktury / klasy, która jest wskaźnikiem zamiast odniesienia.

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;

Otóż ​​to!

a->bjest po prostu skrótem (*a).bpod każdym względem (to samo dla funkcji: a->b()jest skrótem od (*a).b()).

Dodałbym do odpowiedzi „dlaczego?”.

.jest standardowym operatorem dostępu do elementu, który ma wyższy priorytet niż *operator wskaźnika.

Kiedy próbujesz uzyskać dostęp do wewnętrznych struktur i napisałeś to, *foo.barwtedy kompilator pomyślałby, że chce mieć element „bar” z „foo” (który jest adresem w pamięci) i oczywiście ten adres nie ma żadnych elementów.

Dlatego musisz poprosić kompilator, aby najpierw wyrenderował opcję whith, (*foo)a następnie uzyskał dostęp do elementu członkowskiego: (*foo).barco jest nieco niezdarne do pisania, więc dobrzy ludzie wymyślili skróconą wersję: foo->barktóra jest rodzajem dostępu do członka przez operatora wskaźnika.

foo->barjest tylko skrótem (*foo).bar. To wszystko.

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

Tutaj aby uzyskać dostęp do wartości ii jmożemy użyć zmiennej ai wskaźnik pw następujący sposób: a.i, (*p).ii p->iwszystkie są takie same.

Oto .„Selektor bezpośredni” i ->„Selektor pośredni”.

Cóż, muszę też coś dodać. Struktura jest nieco inna niż tablica, ponieważ tablica jest wskaźnikiem, a struktura nie. Więc uważaj!

Powiedzmy, że piszę ten bezużyteczny fragment kodu:

#include <stdio.h>

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

int main(void){

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

}

Tutaj wskaźnik ptrwskazuje na adres ( ! ) Zmiennej struktury, audiale oprócz struktury adresu ma również fragment danych ( ! )! Pierwszy element fragmentu danych ma ten sam adres, co sama struktura, i możesz uzyskać dane, usuwając tylko taki wskaźnik *ptr (bez nawiasów klamrowych) .

Ale jeśli chcesz uzyskać dostęp, innego członka niż pierwszy, trzeba dodać oznacznik jak .km, .kph, .kgktóre nie są niczym więcej niż offsetu do adresu bazowego w porcji danych ...

Ale ze względu na preceedence nie można zapisać *ptr.kgjako operator dostępu .jest oceniany przed operatorem dereference *i można dostać *(ptr.kg), co nie jest możliwe, gdyż wskaźnik nie ma z nami! Kompilator wie o tym i dlatego spowoduje błąd, np .:

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

Zamiast tego używasz tego (*ptr).kgi zmuszasz kompilator do 1. dereferencji wskaźnika i umożliwienia dostępu do części danych i 2. dodajesz przesunięcie (desygnator), aby wybrać element członkowski.

Sprawdź to zdjęcie, które wykonałem:

Ale jeśli zagnieździlibyśmy członków, ta składnia stałaby się nieczytelna i dlatego ->została wprowadzona. Myślę, że czytelność jest jedynym uzasadnionym powodem korzystania z niej, ponieważ ptr->kgjest to o wiele łatwiejsze do napisania niż(*ptr).kg .

Teraz napiszmy to inaczej, aby lepiej widzieć połączenie. (*ptr).kg⟹ (*&audi).kg⟹ audi.kg. Tutaj najpierw wykorzystałem fakt, że ptrjest to „adres audi”, tj. &audiFakt, że operatory „referencyjny” & i „dereferencyjny” wzajemnie się * znoszą.

Musiałem wprowadzić niewielką zmianę w programie Jacka, aby go uruchomić. Po zadeklarowaniu wskaźnika struct pvar, wskaż go na adres var. Znalazłem to rozwiązanie na stronie 242 programowania Stephena Kochana w 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;
}

Uruchom to w vimie za pomocą następującego polecenia:

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

Wyjdzie:

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;
}

->Operatora sprawia, że kod jest bardziej czytelny niż *operator w niektórych sytuacjach.

Takich jak: (cytowany z projektu 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;

};

Struktura _EFI_BLOCK_IO_PROTOCOLzawiera 4 elementy wskaźnika funkcji.

Załóżmy, że masz zmienną struct _EFI_BLOCK_IO_PROTOCOL * pStructi chcesz użyć starego dobrego *operatora, aby wywołać jego wskaźnik funkcji członka. Otrzymasz kod taki jak ten:

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

Ale z ->operatorem możesz napisać w ten sposób:

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

Który wygląda lepiej?

#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);
}

wyjście wynosi 5 5 5

Kropka jest operatorem dereferencyjnym i służy do łączenia zmiennej struktury dla określonego zapisu struktury. Np .:

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

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

W ten sposób możemy użyć operatora kropki, aby uzyskać dostęp do zmiennej struktury