Использование оператора стрелки (->) в C

Я читаю книгу под названием «Обучи себя 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компилятор может захотеть получить элемент 'foo' в 'foo' (который является адресом в памяти) и, очевидно, этот простой адрес не имеет никаких членов.

Таким образом, вам нужно попросить компилятор сначала разыменовать whith, (*foo)а затем получить доступ к элементу member:, (*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-й разыменования указателя и включить Асесс в порции данных и второго добавления смещения (обозначение) , чтобы выбрать элемент.

Проверьте это изображение, которое я сделал:

Но если бы вы имели вложенные члены, этот синтаксис стал бы нечитаемым и, следовательно, -> был введен. Я думаю, что удобочитаемость является единственной оправданной причиной для его использования, поскольку это ptr->kgгораздо проще, чем писать (*ptr).kg.

Теперь давайте напишем это по-другому, чтобы вы видели связь более четко. (*ptr).kg⟹ (*&audi).kg⟹ audi.kg. Здесь я впервые использовал тот факт, что ptrэто «адрес audi», т. &audiЕ. И тот факт, что операторы «ссылка» & и «разыменование» * отменяют друг друга.

Я должен был сделать небольшое изменение в программе Джека, чтобы заставить ее работать. После объявления структурного указателя pvar укажите его адрес var. Я нашел это решение на странице 242 Программирования Стивена Кочана в 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;
}

Запустите это в 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;

};

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

Таким образом, мы можем использовать оператор точки для доступа к структурной переменной