Foo ->bar等价于(* Foo)。Bar，即它从foo指向的结构体中获取名为Bar的成员。

是的，就是这样。

它只是点版本，当你想访问一个结构/类的元素是一个指针，而不是一个引用。

struct foo
{
  int x;
  float y;
};

struct foo var;
struct foo* pvar;
pvar = malloc(sizeof(struct foo));

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).bar的简写。这就是它的全部。

Dot是一个解引用操作符，用于连接结构的特定记录的结构变量。 例如:

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

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

这样，我们就可以使用点运算符来访问结构变量

我不得不对杰克的程序做了一些小改动才能让它运行起来。在声明结构指针pvar后，将其指向var的地址。我在Stephen Kochan的C编程第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;

};

_EFI_BLOCK_IO_PROTOCOL结构体包含4个函数指针成员。

假设你有一个变量结构_EFI_BLOCK_IO_PROTOCOL * pStruct，你想使用老的*操作符来调用它的成员函数指针。你最终会得到这样的代码:

(* pStruct) .ReadBlocks参数(……)

但是使用->操作符，你可以这样写:

pStruct - > ReadBlocks参数(……)。

哪个看起来更好?

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

在这里要访问i和j的值，我们可以使用变量a和指针p，如下所示:a.i， (*p)。I和p-> I都是一样的。

在这里。是“直接选择器”，->是“间接选择器”。

我只想在答案中加上一个“为什么”。

． 标准成员访问操作符，其优先级高于*指针操作符。

当你试图访问一个结构的内部，你把它写成*foo。Bar然后编译器会认为需要一个'foo'(内存中的地址)的' Bar '元素，显然这个地址没有任何成员。

因此，你需要要求编译器先对(*foo)解引用，然后访问成员元素:(*foo)。Bar，写起来有点笨拙，所以好事者想出了一个简写版本:foo-> Bar，这是一种指针操作符的成员访问。

#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

我还得补充点什么。结构与数组有点不同，因为数组是指针，而结构不是。所以要小心!

假设我写了这段无用的代码:

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

相反，您可以使用this (*ptr)。Kg和你强迫编译器首先解引用指针，并允许访问数据块和第二你添加一个偏移量(指示符)选择成员。

看看我做的这张图:

但是如果你有嵌套的成员，这个语法将变得不可读，因此->被引入。我认为可读性是使用它的唯一合理的原因，因为这个ptr->kg比(*ptr).kg更容易编写。

现在让我们用不同的方式来写，这样你就能更清楚地看到其中的联系。(* ptr)。Kg⟹(*&奥迪)。Kg⟹audi.kg。这里我首先使用了ptr是“audi的地址”，即&audi，以及“引用”&和“解引用”*操作符相互抵消的事实。