Question

在数组中使用.和->之间有什么区别？那就是：

(*foo[i]).bar

VS

foo[i]->bar

或：它们是一样的吗？

修改：顺便说一句，另一个参考仅在foo.bar和foo->bar之间询问。我知道不同之处。但是最近，当我认为它应该是(*foo).bar时，我正在阅读一些使用foo->bar的示例。

Answer 1

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

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

如果您接受2个陈述并用第3个表格替换它们：

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

VS

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

您可以通过简单的测试来确认：

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

如果它们相同，那么第三个断言就会失败，输出就不会是它。

Answer 2

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

Answer 3

首先，阵列增加了一些混乱。假设你问的是

之间的区别

(*x).bar;

VS

x->bar;

对于x某种类型T的实例，然后对于指针，两者是等价的：两者都取消引用某个类型的指针来访问成员。但是因为在C ++中，你可以在这里为用户定义的类型重载两个运算符，即operator->()和operator *()，你可以具有两个代码的情况样本不等同。这不应该在任何合理的代码中发生，但它是可能的。以下代码示例说明了这一点：

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

输出：

酒吧!!!

富!!!

Answer 4

1 .-＆GT;用于通过指向对象

的指针访问对象成员变量和方法

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

2 ..用于通过对象实例访问对象成员变量和方法

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

'。'之间有什么区别？和' - ＆gt;'在数组中使用？

4 个答案: