blocks|key|306369|text|数组可以衰减到指针，这些指针指向数组的第一个元素。例如，您可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|306370|void+bar(int*)+{}

int+a[42]+=+{};
int*+b+=+a;++++++//+a+decayed+to+int*,+got+assigned+to+b
bar(a);++++++++++//+a+decayed+to+int*+to+match+bar+parameter+type|code-block|syntax|javascript|306371|在您的示例中，当应用foo运算符时，foo会衰减到指向数组foo的第一个元素的指针。以下两项是相等的：|offset|length|style|CODE|306372|foo->bar();
(&foo[0])->bar();|306373|关于指向的对象的有效性，数组(如|306374|Foo+foo[3];|306375|始终包含3个默认初始化的Foo对象。您所做的是显式地初始化它们，但这不会改变任何事情。数组包含用于初始化其元素的对象的副本。|306376|entityMap^0|0|0|A|3|I|3|T|3|0|0|0|0|C|3|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@$I|Z|J|10|K|L]|$I|11|J|12|K|L]|$I|13|J|14|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|18|8|@$I|19|J|1A|K|L]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|V|$]]

Arrays are allowed to decay to pointers, and these point to the first element of the array. So for example, you can do this:

<pre><code>void bar(int*) {}

int a[42] = {};
int* b = a; // a decayed to int*, got assigned to b
bar(a); // a decayed to int* to match bar parameter type
</code></pre>

In your example, <code>foo</code> decays to a pointer to the first element of the array <code>foo</code> when you apply the <code>-&gt;</code> operator. The following two are equivalent:

<pre><code>foo-&gt;bar();
(&amp;foo[0])-&gt;bar();
</code></pre>

Concerning the validity of the object pointed at, an array such as 

<pre><code>Foo foo[3];
</code></pre>

always contains 3 default initialized <code>Foo</code> objects. What you have done is initialize them explicitly, but that doesn't change anything. The array contains copies of the objects you used to initialize its elements.

blocks|key|5421648|text|我以为操作符->只用于指向对象的指针，而在这段代码中我没有看到任何指针。
|type|blockquote|depth|inlineStyleRanges|entityRanges|data|5421649|unstyled|5421650|数组在表达式中使用时会衰减为指针，就像您已经使用的那样。|5421651|即使有指针，它们也会因为临时的愚人而悬挂指针。是什么让这成为可能？
|5421652|5421653|线|5421654|+Foo+foo[3]+=+{+Foo(),+Foo(),+Foo()+}|code-block|syntax|javascript|5421655|用三个有效的对象填充foo，而不是临时对象。|offset|length|style|CODE|5421656|entityMap^0|0|0|0|0|0|0|0|A|3|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|-4|5|C|7|Y|8|@]|9|@]|A|$]]|$1|D|3|E|5|C|7|Z|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|10|8|@]|9|@]|A|$]]|$1|H|3|-4|5|C|7|11|8|@]|9|@]|A|$]]|$1|I|3|J|5|C|7|12|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|13|8|@]|9|@]|A|$N|O]]|$1|P|3|Q|5|C|7|14|8|@$R|15|S|16|T|U]]|9|@]|A|$]]|$1|V|3|-4|5|C|7|17|8|@]|9|@]|A|$]]]|W|$]]

<blockquote>
 I thought operator-> was only for pointers to objects, and I don't see any pointers in this code.
</blockquote>

An array decays to pointer when used in an expression like you have.

<blockquote>
 Even if there were pointers, they'd be dangling pointers because of the Foo temporaries. What makes this possible?
</blockquote>

The line 

<pre><code> Foo foo[3] = { Foo(), Foo(), Foo() }
</code></pre>

fills <code>foo</code> with three valid objects, not temporaries.

blocks|key|296507|text|您可以声明一个由3个Foo实例组成的数组。通过使用{+Foo(),+Foo(),+Foo()+}创建3个实例来初始化数组，并且它们不会被移动或复制到数组中，它们实际上是在那里创建的，因此不存在临时的实例。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|296508|entityMap^0|A|3|P|N|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

You declare an array of 3 <code>Foo</code> instances. You initialize the array by creating 3 instances with <code>{ Foo(), Foo(), Foo() }</code> and they are not moved or copied into place in the array, they are actually created there, so no temporaries exist.

blocks|key|306483|text|您实际上可以在数组上使用operator->。
|type|blockquote|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|306484|unstyled|306485|是的，标准的数组到指针的转换意味着数组类型的表达式(如foo+)可以衰减为指向第一个数组元素的指针，如果它用于预期指针的上下文中。|306486|我以为操作符->只适用于指向对象的指针
|306487|306488|它适用于可转换为对象指针(包括数组)的任何类型，也适用于重载的任何类类型。|306489|即使有指针，它们也会因为Foo临时程序而悬挂指针。
|306490|306491|不，foo不是临时的，它包含的元素也不是。您通过复制临时程序来初始化它们，但是数组中的副本与数组本身一样持久。|306492|entityMap^0|C|A|0|0|R|3|0|0|0|0|C|3|0|0|2|3|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|G|7|Y|8|@]|D|@]|E|$]]|$1|H|3|I|5|G|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|12|8|@]|D|@]|E|$]]|$1|L|3|-4|5|G|7|13|8|@]|D|@]|E|$]]|$1|M|3|N|5|G|7|14|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|G|7|18|8|@]|D|@]|E|$]]|$1|R|3|S|5|G|7|19|8|@$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|T|3|-4|5|G|7|1C|8|@]|D|@]|E|$]]]|U|$]]

<blockquote>
 You can actually use <code>operator-&gt;</code> on arrays.
</blockquote>

Yes, the standard array-to-pointer conversion means that an expression of array type, like <code>foo</code>, can decay to a pointer to the first array element if it's used in a context where a pointer is expected.

<blockquote>
 I thought operator-> was only for pointers to objects
</blockquote>

It's for any type that's convertible to an object pointer - including an array - and for any class type that it's overloaded for.

<blockquote>
 Even if there were pointers, they'd be dangling pointers because of the <code>Foo</code> temporaries.
</blockquote>

No, <code>foo</code> is not a temporary, and neither are the elements it contains. You initialised them by copying temporaries, but the copies in the array last as long as the array itself.

I just discovered this weird syntax by accident. You can actually use operator-> on arrays.

<pre><code>struct Foo
{
 void bar() { }
};

int main()
{
 Foo foo[3] = { Foo(), Foo(), Foo() };
 foo-&gt;bar();
}
</code></pre>

I thought operator-> was only for pointers to objects, and I don't see any pointers in this code. Even if there were pointers, they'd be dangling pointers because of the Foo temporaries. What makes this possible?

Using -> operator on arrays

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我只是偶然发现了这个奇怪的语法。实际上，可以使用运算符-> on数组。struct Foo{    void bar() { }};int main(){    Foo foo[3] = { Foo(), Foo(), Foo() };    foo->bar();}我以为操作符->只用于指向对象的指针，而在这段代码中...

问在数组上使用->算子
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在数组上使用->算子EN