C dilinde ok operatörü (->) kullanımı

"21 Günde Kendine C Öğret" adlı bir kitap okuyorum (Java ve C # öğrendim, bu yüzden çok daha hızlı ilerliyorum). İşaretçiler hakkındaki bölümü okuyordum ve ->(ok) operatörü açıklama yapmadan geldi. Üyeleri ve işlevleri çağırmak için kullanıldığını düşünüyorum ( .(nokta) operatörünün eşdeğeri gibi , ancak üyeler yerine işaretçiler için). Ama tam olarak emin değilim.

Bir açıklama ve kod örneği alabilir miyim?

foo->bareşittir (*foo).bar, yani üyeyi işaret bareden yapıdan çağırır foo.

Evet, bu o.

Referans yerine işaretçi olan bir yapı / sınıfın öğelerine erişmek istediğinizde yalnızca nokta sürümüdür.

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;

Bu kadar!

a->b(*a).bher şekilde kısadır (işlevler için aynıdır: a->b()kısaltmasıdır (*a).b()).

Sadece "neden?"

.*işaretçi operatöründen daha yüksek önceliğe sahip standart üye erişim operatörüdür.

Bir yapının içlerine erişmeye çalıştığınızda ve bunu yazdığınızda *foo.bar, derleyici 'foo'nun (bellekte bir adres olan) bir' çubuk 'öğesini istemeyi düşünür ve açıkçası bu adresin herhangi bir üyesi yoktur.

Bu yüzden derleyiciden ilk dereference'den nereye başvurmasını istemeniz (*foo)ve daha sonra üye öğeye erişmeniz gerekir: (*foo).barki bu yazı yazmak için biraz sakıncalıdır, böylece iyi insanlar kısa bir versiyonla gelir: foo->barişaretçi operatörü tarafından üye erişimi.

foo->barsadece kestirme yoludur (*foo).bar. Hepsi bu kadar.

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

İşte değerlerini erişmek ive jbiz değişkeni kullanabilirsiniz ave işaretçi paşağıdaki gibi: a.i, (*p).ive p->ihepsi aynı.

İşte ."Doğrudan Seçici" ve ->"Dolaylı Seçici" dir.

Ben de bir şeyler eklemeliyim. Dizi bir işaretçi olduğu ve yapı olmadığı için yapı diziden biraz farklıdır. Yani dikkatli ol!

Diyelim ki bu işe yaramaz kod parçasını yazıyorum:

#include <stdio.h>

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

int main(void){

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

}

Burada işaretçi yapı değişkeninin ptradresini ( ! ) Gösterir,audi ancak adres yapısının yanında da bir veri kümesi ( ! ) Vardır ! Veri yığınının ilk üyesi, yapının kendisiyle aynı adrese sahiptir ve yalnızca böyle bir işaretçiyi kaydırarak *ptr (parantez olmadan) verilerini alabilirsiniz .

Eğer birincisinden daha başka üyesini erişmesine istiyorsanız Ama, böyle bir planlayýcýsý eklemek zorunda .km, .kph, .kgdaha taban adresine uzaklıklar daha hiçbir şey hangi verinin yığın ...

Ancak önkoşul nedeniyle, *ptr.kgerişim operatörü .dereference operatörü önce değerlendirildiğinde yazamazsınız *ve *(ptr.kg)işaretçinin üyesi olmadığı için mümkün olmaz! Derleyici bunu bilir ve bu nedenle bir hata verir:

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

Bunun yerine bunu kullanırsınız (*ptr).kgve derleyiciyi işaretçiyi 1. referanstan ayırmaya zorlar ve veri yığınına erişim sağlar ve 2. üyeyi seçmek için bir ofset (işaretleyici) eklersiniz.

Yaptığım bu görüntüyü kontrol et:

Ancak yuvalanmış üyeleriniz varsa, bu sözdizimi okunamaz hale gelir ve bu nedenle ->tanıtılır. Bence okunabilirlik onu kullanmak için sadece haklı bir sebep, çünkü bu ptr->kgyazmaktan çok daha kolay (*ptr).kg.

Şimdi bağlantıyı daha net görebilmeniz için bunu farklı yazalım. (*ptr).kg⟹ (*&audi).kg⟹ audi.kg. İşte ilk gerçeğini kullanılan ptrbir olan "adresi audi" yani &audive gerçeği "referans" & ve "KQUEUE" * operatörler birbirinden out iptal edin.

Çalıştırmak için Jack'in programında küçük bir değişiklik yapmam gerekiyordu. Yapı işaretçisi pvarını bildirdikten sonra var. Bu çözümü Stephen Kochan'ın C'deki Programlama'nın 242. sayfasında buldum.

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

Bunu aşağıdaki komutla vim'de çalıştırın:

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

Çıktı olacak:

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

->Operatör daha kod daha okunabilir kılan *bazı durumlarda operatör.

Örneğin: ( EDK II projesinden alıntılanmıştır )

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;

};

_EFI_BLOCK_IO_PROTOCOLYapı 4 işlev işaretçisi üyeleri içerir.

Bir değişkeniniz olduğunu struct _EFI_BLOCK_IO_PROTOCOL * pStructve *üye işlev işaretçisi olarak adlandırmak için eski eski operatörü kullanmak istediğinizi varsayalım . Bunun gibi bir kodla karşılaşacaksınız:

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

Ancak ->operatörle şu şekilde yazabilirsiniz:

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

Hangisi daha iyi görünüyor?

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

çıktı 5 5 5

Nokta bir dereference operatörüdür ve belirli bir yapı kaydı için yapı değişkenini bağlamak için kullanılır. Örneğin :

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

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

Bu şekilde yapı değişkenine erişmek için bir nokta operatörü kullanabiliriz