blocks|key|1916423|text|您可以重载->操作符：维基百科。该页面还指出，您不能过载点。有一个->重载这里的例子|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1916424|class+String+//+this+is+handle
{
++...
++Stringrep+*operator+->+()+const+{+return+b_;+}
++private:
++Stringrep+*b_;
}|code-block|syntax|javascript|1916425|箭头在箭头左边的值上工作，并返回左手边“保持在里面”的任何东西。想想智能指针吧。|1916426|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Operators_in_C_and_C%252B%252B|1|http://cpptruths.blogspot.com/2005_10_09_archive.html|2|http://en.wikibooks.org/wiki/C%2B%2B_Programming/Operators/Operator_Overloading#Address_of.2C_Reference.2C_and_Pointer_operators^0|B|4|0|11|2|1|0|0|Y|4|2|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]|$A|10|B|11|1|12]]|C|$]]|$1|D|3|E|5|F|7|13|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]]|C|$]]|$1|K|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]|U|$5|N|O|P|C|$Q|V]]]]

You can overload the -> operator: <a href="http://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B" rel="nofollow">Wikipedia</a>. That page also states that you can't overload dot. There's an example of -> overloading <a href="http://cpptruths.blogspot.com/2005_10_09_archive.html" rel="nofollow">here</a>:

<pre><code>class String // this is handle
{
 ...
 Stringrep *operator -&gt; () const { return b_; }
 private:
 Stringrep *b_;
}
</code></pre>

The arrow works on the value to the left of the arrow and returns whatever the left hand side is "holding inside". Think of a <a href="http://en.wikibooks.org/wiki/C++_Programming/Operators/Operator_Overloading#Address_of.2C_Reference.2C_and_Pointer_operators" rel="nofollow">smart pointer</a>.

blocks|key|2273183|text|我认为，您可以使用"+operator“关键字重载->操作符这一事实应该是一个死胡同。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2273184|聪明的指针经常这样做：|2273185|template<class+T>
struct+myPtr+{
++++T+*operator+->()++++{+return+m_ptr;+}

++++private:
++++++++T+*m_ptr;
};|code-block|syntax|javascript|2273186|.不是可重载的，但定义上也是一个运算符。|2273187|entityMap^0|P|2|0|0|0|0|1|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|U|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

I think the fact that you can overload the <code>-&gt;</code> operator using the "operator" keyword should be a dead giveaway.

Smart pointers do it pretty often:

<pre><code>template&lt;class T&gt;
struct myPtr {
 T *operator -&gt;() { return m_ptr; }

 private:
 T *m_ptr;
};
</code></pre>

The <code>.</code> is not overloadable, but is also an operator by definition.

blocks|key|718671|text|此引用说明它们都是C%2B%2B中的运算符：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|718672|http://www.cplusplus.com/doc/tutorial/operators/|offset|length|718673|这还不够权威吗？|718674|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1C|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@$D|Q|E|R|1|S]]|A|$]]|$1|F|3|G|5|6|7|T|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|C]]]]

This reference says they're both operators in C++:

<a href="http://www.cplusplus.com/doc/tutorial/operators/" rel="nofollow">http://www.cplusplus.com/doc/tutorial/operators/</a>

Is that not authoritative enough?

blocks|key|1916469|text|THe+C%2B%2B03标准将两者都称为运算符。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1916470|示例：|1916471|...after+.运算符应用于其类类型的表达式..。|blockquote|1916472|如果您对这个术语不满意，可以使用标点符号一词来表示.。|offset|length|style|CODE|1916473|entityMap^0|0|0|0|P|1|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|R|8|@$I|S|J|T|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|N|$]]

THe C++03 standard refers to both as operators. 

Example:

<blockquote>
 ...after the . operator applied to an expression of the type of its class...
</blockquote>

If you are not comfortable with that terminology you can use the term punctuator for <code>.</code>.

blocks|key|2273229|text|假设唯一可以作为参数传递给运算符的类型是可以在语言中定义的类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2273230|我认为，编译器可以识别的任何类型都可以作为参数传递，包括内部类型(如“标识符”)。操作符将在其AST表示中包含两个参数，这足以允许您定义语义。|2273231|另一个论点是，语言理论可能为你的词汇表提供了一套定义，但这并不是唯一的一种。|2273232|例如，操作人员可能是操作机器的人。这个定义与编程理论无关，但它不会阻止我在特定于领域的语言中使用与机器操作有关的关键字。类似地，“运算符”一词在数学中的定义比编程理论的定义更广--而且这个定义并不仅仅通过使用一种编程语言就失效了。|2273233|换句话说--如果你不叫它接线员，你会怎么称呼它？|2273234|编辑|offset|length|style|BOLD|2273235|为了澄清，我的第一个参数是指使用运算符(调用)的语法。这些运算符具有正确的参数，这些参数是标识符(成员名称)，C%2B%2B语言无法使用数据类型表示这些参数。C%2B%2B语言确实有成员指针，但它们与成员不一样--就像变量与指向该变量的指针不同一样。|2273236|我想这就是问题所指的。这些运算符的正确参数有一种类型，不能用该语言表示或正常操作。|2273237|当该语法映射到重载的operator->函数时会发生什么，这是另一回事。函数不是操作符，而是操作符的实现方式。|CODE|2273238|entityMap^0|0|0|0|0|0|0|2|0|0|0|A|A|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|13|8|@$L|14|M|15|N|O]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|16|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|17|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|18|8|@$L|19|M|1A|N|V]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|X|$]]

You assume that the only types which can be passed as arguments to an operator are types that can be defined within the language.

I would argue that any type which can be recognised by the compiler may be passed as an argument, including internal types such as "identifier". The operator will have two arguments in its AST representation, which is enough to allow you to define semantics.

Another argument is that language theory may provide one set of definitions for your vocabulary, but it isn't the only one.

For example, an operator may be a man who works a machine. That definition has no relevance to programming theory, but it won't stop me using for keywords in a domain-specific language expressing something to do with machine operating. Similarly, the term "operator" has a wider definition in mathematics than that which is specific to programming theory - and that definition isn't invalidated simply by working with a programming language.

To put it another way - if you didn't call it an operator, what would you call it?

EDIT

To clarify, my first argument is referring to the syntax for using the operator (the call). These operators have right arguments which are identifiers - member names - which the C++ language cannot express using a data type. The C++ language does have member pointers, but they aren't the same thing as the members - just as a variable isn't the same as a pointer to that variable.

I assume that is what the question referred to. The right parameter of those operators has a type which cannot be expressed or manipulated normally in the language.

What happens when that syntax is mapped to an overloaded <code>operator-&gt;</code> function is a different thing. The function isn't the operator - it's only how the operator gets implemented.

blocks|key|2273268|text|嗯.sizeof是一个操作符，它的输入类型是什么？在这种情况下，我不认为这个问题对区分操作符和非操作符是有用的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2273269|这将是因为“运算符”在编程语言中的意思正是语言的作者所说的意思。这是刘易斯·卡罗尔的影子。|2273270|entityMap^0|2|6|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

Hmmm...<code>sizeof</code> is an operator, what is its input type? I don't think the question is useful for distinguishing operators from non-operators in this context.

And that would be because what "operator" means in the context of a programming language is exactly what the author of the language says it means. Shades of Lewis Carroll here.

blocks|key|1916506|text|哈哈，我知道人们已经用一种迂回的方式说了这句话，只是直接说出来而已。在C术语中，label->实际上是(*label)的缩写。有人说.That。引用结构中元素的运算符。因此，->引用指针中指向结构的元素。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1916507|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

haha, i know people have already said this in a roundabout way but just to say it directly. In C terms, label-> is actually a shorthand for (*label). .That being said, . is the operator which references elements in a struct. Therefore, -> references an element in a pointer to a struct.

you probably have been tought, are tought yourselves, that . and -> are operators which retrieve members of a struct (C) or class (C++).

However, I doubt they are operators - because, if they are operators, what are their input types? Furthermore, the identifiers on both sides are interdependent - a feature which for example the + operator lacks of.

If this is correct - in what sense are these still labeled as operator in practice, and what is their formal definition with regard to language theory.

Are . and -> in C and C++ really operators?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

你们可能已经被出卖了，你们自己也是如此。->是操作符，它检索结构(C)或类(C++)的成员。但是，我怀疑它们是否是运算符--因为，如果它们是运算符，它们的输入类型是什么？此外，双方的标识符是相互依赖的--例如+运算符缺乏的特性。如果这是正确的-在什么意义上，这些仍然被标记为运算符在实践中，以及他们的形式定义对语言理论。

问都是。而->在C和C++中真的是运算符吗？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问都是。而->在C和C++中真的是运算符吗？EN