C++ 中 object->function() 和 object.function() 之间的区别

发布于 2024-11-13 08:51:04 字数 129 浏览 6 评论 0原文

谁能解释一下这样做之间的区别：

a->height();

和

a.height();

实际上有区别吗？

原文

Can anyone explain the different between doing something like:

a->height();

and

a.height();

Is there actually a difference?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

瀟灑尐姊 2024-11-20 08:51:04

在第一个示例中，a 是指向对象的指针，在第二个示例中，它是对象本身（或对象的引用）。在最低级别上，两者之间没有明显区别。

回复收藏 0 原文

遗弃Ｍ 2024-11-20 08:51:04

这是一个奇怪的问题，假设我们正在讨论内置的 ->。听起来有点像“锤子和苹果有什么区别”。通常，当两种变体至少在某种程度上可以互换且同时适用时，就会出现有关“差异”的问题。因此，人们会询问“差异”来决定使用哪种变体。这里的情况并非如此。

您不能让 a->height() 和 a.height() 同时有效。两者中只有一个有效，具体取决于 a 的类型。也就是说，您无法选择使用哪个版本。如果左侧是指向对象的指针，则第一个（带有 ->）适用。第二个（只有 .）仅适用于左侧是对象值本身的情况。所以，这就是全部。

-> 只是一元 * 和 . 组合的简写，意味着当 a 为指针a->height()相当于(*a).height()。因此，一个更合理的问题是关于 a->height() 和 (*a).height() 之间的区别。答案是：没有区别（同样，只要我们考虑内置的 ->）

回复收藏 0 原文

卖梦商人 2024-11-20 08:51:04

它基本上归结为你如何声明“a”。如果你这样做：

SomeClass a;

那么“a”本身就是一个对象，并且你使用“.”。参考其成员。

如果你这样做：

SomeClass * a;
a = [some expression that produces a pointer to a SomeClass object];

那么“a”是一个指向对象的指针，而不是它本身是一个对象。然后你使用“->”符号。

（上述规则存在一些潜在的例外情况，但大多数人都不会遇到。）

It basically boils down to how you declared "a". If you do:

SomeClass a;

then "a" is itself an object, and you use "." to reference its members.

If you do:

SomeClass * a;
a = [some expression that produces a pointer to a SomeClass object];

then "a" is a POINTER TO an object, not itself an object. Then you use the "->" notation.

(There are some potential exceptions to the above rules, but they're not something most people ever encounter.)

回复收藏 0 原文

滥情稳全场 2024-11-20 08:51:04

还值得一提的是，某些对象（例如智能指针）支持两种表示法。在这种情况下，第一个将引用指针指向的对象，第二个将引用智能指针本身。

回复收藏 0 原文

寂寞陪衬 2024-11-20 08:51:04

operator-> 后跟函数调用，将导致返回的指针被取消引用，并在结果对象上调用函数。简而言之，a->foo() 是 (*a).foo() 的简写。

除了 a->foo() 要求 a 是指向定义 foo 的类的指针这一正确答案之外，一个人为的示例可能是告诉一些不同的事情：

struct xC {
   struct Member {
      void foo(){printf("xC::Member::foo\n");};
   };
   Member a;
   Member* operator->() { return &a; }
   // following function doesn't really make sense.
   void foo() { printf("xC::foo\n");};
};

int main(){
    xC x;
    x.foo(); // prints "xC::foo".  
    x->foo();// prints "xC::Member::foo"
}

在智能指针和 stl 迭代器的上下文中，您经常会看到这些类型的 operator-> 定义。在这种情况下，该定义确实遵循 Stroustrup 的准则，即不要将其滥用于违反直觉的内容，例如我的示例，而是使定义类可用，就好像它“指向”某个对象一样。

The operator->, followed by a function call, will result in the returned pointer being dereferences, and the function being called on the resulting object. In short, a->foo() is shorthand for (*a).foo().

Apart from the correct answer that a->foo() requires a to be a pointer to a class defining foo, a contrived example may tell something different:

struct xC {
   struct Member {
      void foo(){printf("xC::Member::foo\n");};
   };
   Member a;
   Member* operator->() { return &a; }
   // following function doesn't really make sense.
   void foo() { printf("xC::foo\n");};
};

int main(){
    xC x;
    x.foo(); // prints "xC::foo".  
    x->foo();// prints "xC::Member::foo"
}

In the context of smartpointers and the stl iterators, you will often see these kinds of operator-> definition. In that context, the definition does follow Stroustrup's guideline to not abuse it for something counter-intuitive, like my example, but to make the defining class usable as if it were 'pointing' to some object.

回复收藏 0 原文

好菇凉咱不稀罕他 2024-11-20 08:51:04

假设 a 是指向某个对象的指针，那么：

这：

a->height();

只是简写：

(*a).height();

它允许您通过指针而不仅仅是普通对象（或引用）来调用方法。
您实际上不需要使用 ->;版本，但是当您将几个调用链接在一起时，它的用处就显而易见了。

person->body()->arm(right)->hand()->finger(index)->ring()->activate();

如果你写这么长的话，那就是：

(*(*(*(*(*(*person).body()).arm(right)).hand()).finger(index)).ring()).activate();

很难将取消引用（*）与其取消引用的指针相关联。而第一个版本->左边的东西是一个指针，右边的东西是指针被取消引用后对象的一部分。

Assuming that a is a pointer to some object then:

This:

a->height();

Is just shorthand for:

(*a).height();

It allows you to call a method via a pointer rather than just a plain object (or reference).
You don't actually need to use the -> version but when you chain a couple of calls togther it becomes obvious why it is useful.

person->body()->arm(right)->hand()->finger(index)->ring()->activate();

If you write this long hand it is:

(*(*(*(*(*(*person).body()).arm(right)).hand()).finger(index)).ring()).activate();

Its hard to correlate the de-reference (the *) to the pointer it is de-referencing. While the first version -> the thing on the left is a pointer the thing on the right the part of the object after the pointer has been de-referenced.

回复收藏 0 原文

平安喜乐 2024-11-20 08:51:04

正如其他人所说，如果您正在谈论指针的取消引用，那么差异不会非常显着。但更重要的是，如果 a 是实例或引用并且定义了 operator-> 函数，那么您可能会看到非常不同的行为。 a.name() 会调用 a 的 name() 函数，而 a->name() 可能会调用其他类型的 name() 函数以及该类决定执行的任何其他工作（这是一个返回指针的函数调用，因此“邪恶”类只要返回一个有效的指针就可以做它想做的大多数事情）。这主要用于智能指针，但语言中对此没有保证。