Використання оператора стрілки (->) в С

Я читаю книгу під назвою "Навчи себе C за 21 день" (я вже навчився Java та C #, тому я рухаюся значно швидшими темпами). Я читав розділ про вказівники і оператор-> (стрілка) підійшов без пояснень. Я думаю, що він використовується для виклику членів та функцій (як еквівалент оператора (крапка), але для покажчиків замість членів). Але я не зовсім впевнений..

Чи можу я отримати пояснення та зразок коду?

foo->barеквівалентний (*foo).bar, тобто отримує член, викликаний barіз структури, на яку fooвказує.

Так, це все.

Це просто точка-версія, коли ви хочете отримати доступ до елементів структура / класу, що є вказівником замість посилання.

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;

Це воно!

a->bпросто короткий для (*a).bвсіх способів (те ж саме для функцій: a->b()є скороченням для (*a).b()).

Я просто доповню відповіді "чому?".

.є стандартним оператором доступу з членами, який має більший пріоритет, ніж *оператор покажчика.

Коли ви намагаєтеся отримати доступ до внутрішніх даних структури, і ви написали це так, як *foo.barтоді компілятор подумав би, що потрібен елемент 'bar' 'foo' (що є адресою в пам'яті), і очевидно, що проста адреса не має членів.

Таким чином, вам потрібно попросити компілятора спочатку знеструмити те, (*foo)а потім отримати доступ до елемента-члена:, (*foo).barякий трохи незграбно писати, тому добрі люди придумали скорочену версію: foo->barяка є своєрідним доступом до члена оператора вказівника.

foo->barє лише скороченням для (*foo).bar. Це все, що там є.

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

Тут , щоб отримати доступ до значень iі jми можемо використовувати змінні aі покажчик pнаступним чином : a.i, (*p).iі p->iвсе ж.

Ось ."Прямий селектор" і ->"Непрямий селектор".

Ну, я також повинен щось додати. Структура трохи відрізняється від масиву, оскільки масив - це вказівник, а структура - ні. Тож будьте обережні!

Скажемо, я пишу цей марний фрагмент коду:

#include <stdio.h>

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

int main(void){

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

}

Тут вказівник ptrвказує на адресу ( ! ) Змінної структури, audiале поряд із структурою адреси також є шматок даних ( ! )! Перший член фрагмента даних має таку ж адресу, що і сама структура, і ви можете отримати його дані, лише скасувавши такий покажчик *ptr (без дужок) .

Але якщо ви хочете Асесс будь-якого іншого члена , ніж перший, ви повинні додати умовне позначення , як .km, .kph, .kgякі є не більше , ніж зміщення до базового адресою порції даних ...

Але через перевагу ви не можете записати, *ptr.kgоскільки оператор доступу .оцінюється перед оператором скидання, *і ви отримаєте, *(ptr.kg)що неможливо, оскільки вказівник не має членів! І компілятор це знає і тому видасть помилку, наприклад:

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

Замість цього ви використовуєте це, (*ptr).kgі ви змушуєте компілятор виконувати 1-ю дереференцію вказівника і вмикати доступ до фрагменту даних, а 2-го додаєте зміщення (позначення) для вибору члена.

Перевірте це зображення, яке я зробив:

Але якби ви вклали членів, цей синтаксис став би нечитабельним і тому ->був введений. Я думаю, що читабельність є єдиною виправданою причиною його використання, оскільки це ptr->kgнабагато простіше написати, ніж (*ptr).kg.

Тепер напишемо це по-іншому, щоб ви бачили зв’язок чіткіше. (*ptr).kg⟹ (*&audi).kg⟹ audi.kg. Тут я вперше застосував той факт, що ptrце "адреса audi", тобто &audiфакт, що оператори "посилання" & та "відвантаження" * скасовують будь-яке інше.

Мені довелося внести невелику зміну в програму Джека, щоб змусити її запускатись. Після оголошення структурного вказівника pvar, вкажіть його на адресу var. Я знайшов це рішення на сторінці 242 Програмування Стівена Кочана в С.

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

Запустіть це в vim за допомогою наступної команди:

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

Виведе:

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

->Оператор робить код більш читабельним , ніж* оператор в деяких ситуаціях.

Такі як: (цитується з проекту 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_PROTOCOLСтруктура містить 4 членів покажчика функції.

Припустимо, у вас є змінна struct _EFI_BLOCK_IO_PROTOCOL * pStruct, і ви хочете використовувати старий добрий *оператор для виклику вказівника функції члена. Ви отримаєте такий код:

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

Але з ->оператором ви можете написати так:

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

Що виглядає краще?

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

вихід 5 5 5

Dot є оператором розвідки і використовується для з'єднання змінної структури для певного запису структури. Наприклад:

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

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

Таким чином, ми можемо використовувати оператор крапки для доступу до змінної структури