Verwendung des Pfeiloperators (->) in C.

Ich lese ein Buch mit dem Titel "Teach Yourself C in 21 Days" (ich habe bereits Java und C # gelernt, daher bewege ich mich viel schneller). Ich habe das Kapitel über Zeiger gelesen und der Operator-> (Pfeil) wurde ohne Erklärung angezeigt. Ich denke, dass es verwendet wird, um Mitglieder und Funktionen aufzurufen (wie das Äquivalent des (Punkt-) Operators, aber für Zeiger anstelle von Mitgliedern). Ich bin mir aber nicht ganz sicher..

Könnte ich bitte eine Erklärung und ein Codebeispiel bekommen?

foo->barist äquivalent zu (*foo).bar, dh es wird das aufgerufene Mitglied baraus der Struktur aufgerufen, die fooauf zeigt.

Ja das ist es.

Es ist nur die Punktversion, wenn Sie auf Elemente einer Struktur / Klasse zugreifen möchten, die ein Zeiger anstelle einer Referenz ist.

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;

Das ist es!

a->bist (*a).bin jeder Hinsicht nur kurz für (gleich für Funktionen: a->b()ist kurz für (*a).b()).

Ich würde den Antworten nur das "Warum?" Hinzufügen.

.ist ein Standardzugriffsoperator für Mitglieder, der eine höhere Priorität als der *Zeigeroperator hat.

Wenn Sie versuchen, auf die Interna einer Struktur zuzugreifen, und Sie es so geschrieben haben, *foo.barwürde der Compiler denken, dass er ein 'bar'-Element von' foo '(eine Adresse im Speicher) haben möchte, und offensichtlich hat diese bloße Adresse keine Mitglieder.

Daher müssen Sie den Compiler bitten, zuerst eine Dereferenzierung mit (*foo)und dann auf das Element element: zuzugreifen. Dies (*foo).barist etwas umständlich zu schreiben, sodass die guten Leute eine Kurzversion entwickelt haben: foo->bareine Art Elementzugriff per Zeigeroperator.

foo->barist nur eine Abkürzung für (*foo).bar. Das ist alles dazu.

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

Hier auf den Zugriff auf die Werte iund jwir können die Variable verwenden aund den Zeiger pwie folgt: a.i, (*p).iund p->isind alle gleich.

Hier .ist ein "Direktwähler" und ->ein "Indirekter Selektor".

Nun, ich muss auch etwas hinzufügen. Die Struktur unterscheidet sich ein wenig vom Array, da das Array ein Zeiger ist und die Struktur nicht. Also sei vorsichtig!

Nehmen wir an, ich schreibe diesen nutzlosen Code:

#include <stdio.h>

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

int main(void){

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

}

Hier zeigt der Zeiger ptrauf die Adresse ( ! ) Der Strukturvariablen, hat audiaber neben der Adressstruktur auch einen Datenblock ( ! )! Das erste Mitglied des Datenblocks hat dieselbe Adresse wie die Struktur selbst, und Sie können die Daten abrufen, indem Sie nur einen Zeiger wie diesen dereferenzieren*ptr (keine geschweiften Klammern) .

Aber Wenn Sie ein anderes Mitglied als das erste Acess wollen, müssen Sie einen Bezeichner hinzufügen wie .km, .kph, .kgdie nichts mehr als Offsets auf die Basisadresse des Datenblock ...

Aufgrund der Vorrangstellung können Sie jedoch nicht schreiben, *ptr.kgda der Zugriffsoperator .vor dem Dereferenzierungsoperator ausgewertet wird *und Sie erhalten, *(ptr.kg)was nicht möglich ist, da der Zeiger keine Mitglieder hat! Und der Compiler weiß das und wird daher einen Fehler ausgeben, zB:

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

Stattdessen verwenden Sie diese (*ptr).kgund Sie Compiler erzwingen 1. den Zeiger dereferenzieren und ermöglichen acess zum Teil der Daten und zweiten Sie einen Offset (Bezeichner) in dem das Element zu wählen.

Überprüfen Sie dieses Bild, das ich gemacht habe:

Wenn Sie jedoch verschachtelte Mitglieder hätten, wäre diese Syntax unlesbar und wurde daher ->eingeführt. Ich denke, Lesbarkeit ist der einzige berechtigte Grund für die Verwendung, da dies ptr->kgviel einfacher zu schreiben ist als(*ptr).kg .

Lassen Sie uns dies jetzt anders schreiben, damit Sie den Zusammenhang klarer sehen. (*ptr).kg⟹ (*&audi).kg⟹ audi.kg. Hier habe ich zuerst die Tatsache verwendet, dass ptres sich um eine "Adresse von audi" handelt, dh die &audiTatsache, dass "Referenz" & und "Dereferenzierung" * -Operatoren gegenseitig aufheben.

Ich musste eine kleine Änderung an Jacks Programm vornehmen, damit es lief. Zeigen Sie nach dem Deklarieren des Strukturzeigers pvar auf die Adresse von var. Ich fand diese Lösung auf Seite 242 von Stephen Kochans Programmierung in 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;
}

Führen Sie dies in vim mit dem folgenden Befehl aus:

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

Wird ausgegeben:

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

Der ->Operator macht den Code lesbarer als den* in einigen Situationen Operator.

Wie zum Beispiel: (zitiert aus dem EDK II-Projekt )

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;

};

Das _EFI_BLOCK_IO_PROTOCOL Struktur enthält 4 Funktionszeigerelemente.

Angenommen, Sie haben eine Variable struct _EFI_BLOCK_IO_PROTOCOL * pStructund möchten den guten alten *Operator verwenden, um den Elementfunktionszeiger aufzurufen. Am Ende erhalten Sie folgenden Code:

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

Mit dem ->Operator können Sie jedoch folgendermaßen schreiben:

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

Welches sieht besser aus?

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

Ausgabe ist 5 5 5

Dot ist ein Dereferenzierungsoperator und wird verwendet, um die Strukturvariable für einen bestimmten Strukturdatensatz zu verbinden. Z.B :

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

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

Auf diese Weise können wir einen Punktoperator verwenden, um auf die Strukturvariable zuzugreifen