C++ 在数组中使用“.”和“->”之间有什么区别？

两者的区别是什么。和->在数组中使用时？即:

(*foo[i]).bar

vs

或者：它们是一样的吗

---

编辑：顺便说一句，另一个参考仅在foo.bar和foo->bar之间查询。我知道其中的区别。但最近，我读了一些使用*foo.bar的示例，我认为应该是foo->bar。

没有区别。但是foo[i]->bar比使用解引用操作符更清晰。特别是当您将有多个级别的指针最终指向对象时，使用解引用操作符将使代码难以理解。

1.->用于通过指向对象的指针访问对象成员变量和方法

Foo *foo = new Foo();
foo->var= 10;
foo->func();

二,。。用于通过对象实例访问对象成员变量和方法

Foo foo;
foo.var= 10;
foo.func();

假设foo是数组中使用的简单POD用户定义类型，那么这两条语句肯定不相同。您可能知道，以下所有内容在上述上下文中具有相同的语义含义：

  *foo
  *(foo + 0)
  foo[0]
  0[foo]

如果您将这两条语句替换为第三种形式，您将得到：

(*foo)[i].bar ==> foo[0][i].bar

vs

您可以通过一个简单的测试来确认这一点：

#include <stdio.h>
#include <assert.h>

struct foo_t
{
  int bar;
};

int main()
{
    foo_t foo[2][2] = { { {0xdeadbeef}, {0xbadbeef} }, 
                        { {0xbadf00d}, {0xdecafbad} } };

    assert((*foo)[1].bar == foo[0][1].bar);
    assert(foo[1]->bar == foo[1][0].bar);
    assert(foo[1]->bar != (*foo)[1].bar);

    printf("(*foo)[1].bar: %x\n", (*foo)[1].bar);
    printf("foo[1]->bar: %x\n", foo[1]->bar);
}

---

如果它们是相同的，那么第三个断言就会失败，输出也不会是原来的样子。

首先，数组增加了一些混乱。假设你问的是两者之间的区别

(*x).bar;

vs

对于某个类型T的实例，那么对于指针，这两者是等价的：两者都取消对某个类型的指针的引用以访问成员。但由于C++中允许在这里为用户定义的类型（即运算符->和操作符*）加载两个操作符，所以可以有两个代码样本不等价的情况。这不应该发生在任何正常的代码中，但这是一种可能性。以下代码示例说明了这一点：

#include <iostream>
struct Foo
{
  void hello() const { std::cout << "Foo!!!\n"; }
};

struct Bar
{
  void hello() const { std::cout << "Bar!!!\n"; }
};

struct FooBar
{
  Foo foo;
  Bar bar;
  const Foo& operator*() const { return foo; }
  const Bar* operator->() const {return &bar; }
};

int main()
{
  FooBar fb;
  fb->hello();
  (*fb).hello();
}

输出：

酒吧

福

---

别再这样了。。。。。。。。。在健全的代码中，它是相同的。但对于C++中的用户定义类型，可以定义->和*-运算符，这些可以做不同的事情。事实上，我在生产代码中看到了这一点。是什么让你认为数组改变了这些操作符的意思？因为重新打开是浪费时间，因为对于OP的目的，*Fo[i]栏的含义与Fo[i] -> bar相同，尽管C++中的它们可以不同，这个问题和它最近的变化正在讨论中。你可能需要注意一下，我不确定这个答案的措辞。我同意->更清楚，但它仍然在指针中去引用。在C++中，不幸的是，根据FO元素的类型，有差别。严格地说，原始帖子中的代码是错误的。如果foo是指针数组，*运算符的正确语法应该是*foo[i].bar，而不是*foo[i].bar。可以为原始语法正确声明foo，但在任何情况下都不会与foo[i]->bar等价。此答案不再与问题的当前版本一致。@sh1问题不应被实质性更改以影响其含义，即使是OP，如果问题发生了变化，那么“错”的是问题而不是答案。如果OP有一个新问题，他们应该问一个新问题我喜欢你的答案有多彻底，更不用说它是正确的！在*foo[1].bar中，指针首先被取消引用，这意味着foo[0]。然后在元素1访问子数组。然后访问条成员。在foo[1]->bar中，它是foo[1][0]。访问的bar，而不是foo[0][1]。bar。

(*x).bar;

x->bar;

#include <iostream>
struct Foo
{
  void hello() const { std::cout << "Foo!!!\n"; }
};

struct Bar
{
  void hello() const { std::cout << "Bar!!!\n"; }
};

struct FooBar
{
  Foo foo;
  Bar bar;
  const Foo& operator*() const { return foo; }
  const Bar* operator->() const {return &bar; }
};

int main()
{
  FooBar fb;
  fb->hello();
  (*fb).hello();
}