Arrow operator (->) penggunaan dalam C

Saya membaca buku berjudul "Teach Yourself C in 21 Days" (Saya sudah belajar Java dan C # jadi saya bergerak dengan kecepatan yang jauh lebih cepat). Saya membaca bab tentang petunjuk dan operator-> (panah) muncul tanpa penjelasan. Saya pikir itu digunakan untuk memanggil anggota dan fungsi (seperti yang setara dengan operator (titik), tetapi untuk pointer bukan anggota). Tetapi saya tidak sepenuhnya yakin..

Bisakah saya mendapatkan penjelasan dan contoh kode?

foo->barsetara dengan (*foo).bar, yaitu mendapat anggota dipanggil bardari struct yang foomenunjuk ke.

Ya itu saja.

Itu hanya versi titik ketika Anda ingin mengakses elemen struct / kelas yang merupakan pointer bukan referensi.

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;

Itu dia!

a->bhanya kependekan dari (*a).bsegala hal (sama untuk fungsi: a->b()kependekan (*a).b()).

Saya hanya menambahkan jawaban "mengapa?".

.adalah operator akses anggota standar yang memiliki prioritas lebih tinggi daripada *operator pointer.

Ketika Anda mencoba mengakses internal struct dan Anda menulisnya *foo.barmaka kompiler akan berpikir untuk menginginkan elemen 'bar' dari 'foo' (yang merupakan alamat dalam memori) dan jelas bahwa alamat belaka tidak memiliki anggota.

Jadi Anda perlu meminta kompiler untuk dereferensi pertama dengan (*foo)dan kemudian mengakses elemen anggota:, (*foo).baryang agak canggung untuk menulis sehingga orang-orang baik telah datang dengan versi singkat: foo->baryang merupakan semacam akses anggota oleh operator pointer.

foo->barhanya singkatan untuk (*foo).bar. Hanya itu yang ada untuk itu.

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

Berikut untuk mengakses nilai-nilai idan jkita dapat menggunakan variabel adan pointer psebagai berikut: a.i, (*p).idan p->isemua sama.

Inilah ."Pemilih Langsung" dan ->"Pemilih Tidak Langsung".

Yah saya harus menambahkan sesuatu juga. Struktur sedikit berbeda dari array karena array adalah pointer dan struktur tidak. Jadi hati-hati!

Katakanlah saya menulis kode yang tidak berguna ini:

#include <stdio.h>

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

int main(void){

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

}

Di sini pointer ptrmenunjuk ke alamat ( ! ) Dari variabel struktur auditetapi di samping struktur alamat juga memiliki sejumlah data ( ! )! Anggota pertama dari chunk data memiliki alamat yang sama dari struktur itu sendiri dan Anda bisa mendapatkan datanya dengan hanya mereferensikan pointer seperti ini *ptr (tanpa kawat gigi) .

Tapi Jika Anda ingin acess setiap anggota lain dari yang pertama, Anda harus menambahkan penanda seperti .km, .kph, .kgyang tidak lebih dari offset ke alamat dasar potongan data ...

Tetapi karena prioritas Anda tidak dapat menulis *ptr.kgkarena operator akses .dievaluasi sebelum operator dereferensi *dan Anda akan mendapatkan *(ptr.kg)yang tidak mungkin karena pointer tidak memiliki anggota! Dan kompiler mengetahui hal ini dan karena itu akan mengeluarkan kesalahan misalnya:

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

Alih-alih Anda menggunakan ini (*ptr).kgdan Anda memaksa compiler ke 1 dereference pointer dan mengaktifkan acess ke potongan data dan 2 Anda menambahkan offset (penunjuk) untuk memilih anggota.

Periksa gambar yang saya buat ini:

Tetapi jika Anda memiliki anggota bersarang, sintaks ini akan menjadi tidak dapat dibaca dan oleh karena ->itu diperkenalkan. Saya pikir keterbacaan adalah satu-satunya alasan dibenarkan untuk menggunakannya karena ini ptr->kgjauh lebih mudah untuk ditulis daripada (*ptr).kg.

Sekarang mari kita tuliskan ini secara berbeda sehingga Anda melihat hubungannya lebih jelas. (*ptr).kg⟹ (*&audi).kg⟹ audi.kg. Di sini saya pertama kali menggunakan fakta yang ptrmerupakan "alamat audi" yaitu &audidan fakta bahwa operator "referensi" & dan "dereferensi" * membatalkan satu sama lain.

Saya harus membuat perubahan kecil pada program Jack untuk menjalankannya. Setelah mendeklarasikan struct pointer pvar, arahkan ke alamat var. Saya menemukan solusi ini di halaman 242 dari Programming Stephen Kochan di 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;
}

Jalankan ini dalam vim dengan perintah berikut:

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

Akan menghasilkan:

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

The ->Operator membuat kode lebih mudah dibaca daripada *operator dalam beberapa situasi.

Seperti: (dikutip dari proyek 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;

};

The _EFI_BLOCK_IO_PROTOCOLstruct berisi 4 anggota fungsi pointer.

Misalkan Anda memiliki variabel struct _EFI_BLOCK_IO_PROTOCOL * pStruct, dan Anda ingin menggunakan *operator lama yang baik untuk memanggil itu pointer fungsi anggota. Anda akan berakhir dengan kode seperti ini:

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

Tetapi dengan ->operator, Anda dapat menulis seperti ini:

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

Mana yang terlihat lebih baik?

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

output adalah 5 5 5

Dot adalah operator dereference dan digunakan untuk menghubungkan variabel struktur untuk catatan struktur tertentu. Misalnya:

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

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

Sedemikian rupa kita dapat menggunakan operator titik untuk mengakses variabel struktur