blocks|key|300483|text|因为您没有重载operator%2B，所以operator+int()被调用了两次。编译器不知道如何将Base添加到Base中，所以它们被转换为int+(因为您已经教过它如何做)，它知道如何做。下面的代码打印ADA|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|300484|#include+<iostream>

using+namespace+std;

class+Base+{
public:
++++Base(int+m_var=1):i(m_var){
++++++++cout<<"A";
++++}
++++Base(Base&+Base){
++++++++cout<<"B";
++++++++i=Base.i;
++++}
++++operator+int()+{
++++++++cout<<"C";
++++++++return+i;
++++}
++++int+operator%2B(Base&+Base)
++++{
++++++++cout<<"D";
++++++++return+i%2BBase.i;
++++}
private:
++++int+i;
};

int+main()
{
++++Base+obj;
++++obj+=+obj%2Bobj;
++++return+0;
}|code-block|syntax|javascript|300485|entityMap^0|7|9|J|E|1D|4|1K|4|1Y|3|2U|3|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|L|$]]

<code>operator int()</code> is called twice because you haven't overloaded <code>operator+</code>. The compiler doesn't know how to add a <code>Base</code> to a <code>Base</code>, so they are converted to <code>int</code> (since you taught it how to do that), which it does know how to do. The following code prints <code>ADA</code>:

<pre><code>#include &lt;iostream&gt;

using namespace std;

class Base {
public:
 Base(int m_var=1):i(m_var){
 cout&lt;&lt;"A";
 }
 Base(Base&amp; Base){
 cout&lt;&lt;"B";
 i=Base.i;
 }
 operator int() {
 cout&lt;&lt;"C";
 return i;
 }
 int operator+(Base&amp; Base)
 {
 cout&lt;&lt;"D";
 return i+Base.i;
 }
private:
 int i;
};

int main()
{
 Base obj;
 obj = obj+obj;
 return 0;
}
</code></pre>

blocks|key|300497|text|在表达式obj%2Bobj中引用obj两次，每个引用都必须转换为整数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|300498|这并不是不可能的(尽管这是一个可怕的想法)，这样的转换可以是“有状态的”-也就是说，它可以在每次被调用时返回一个不同的值。毕竟，obj表示的值可能会改变(它可能是一个计数器或类似的东西)。因此，编译器必须为每个引用重新计算它。|300499|entityMap^0|4|7|0|1S|3|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|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

You refer to obj twice in the expression <code>obj+obj</code> and each such reference has to be converted to an integer.

It's not impossible (although it is a horrible idea) that such a conversion could be "stateful" - that is, it could by design return a different value each time it is called. After all, the value represented by <code>obj</code> may change (it could be a counter or something like that). So the compiler has to evaluate it afresh for each reference.

blocks|key|82995|text|它是每个操作数调用一次，不管它是不是同一个实例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|82996|+obj+=+obj%2Bobj;|code-block|syntax|javascript|82997|它将第一个操作数“转换”为int，然后将第二个操作数“转换”为int。|82998|如果你想避免这种隐式类型转换，你需要重载运算符%2B。|82999|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

It's call once per operand, it doesn't matter if it is the same instance.

<pre><code> obj = obj+obj;
</code></pre>

It "casts" the first operand to an int, and then the second one.

You need to overload the operator + if you want to avoid this implicit cast.

blocks|key|83052|text|它调用operator+int()两次，因为它需要将这两个obj都转换为int，然后才能将它们相加。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|83053|entityMap^0|3|E|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

It calls <code>operator int()</code> twice because it needs to convert both obj to int before it can add them.

blocks|key|300575|text|当你构造对象时，你会得到第一个"A"：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|300576|+Base+obj;|code-block|syntax|javascript|300577|当您指定添加obj%2Bobj时，编译器需要找出在obj上使用%2B的方法。由于您没有覆盖Base的operator%2B，因此等式的每一端都会调用到int()的转换：|offset|length|style|CODE|300578|obj%2Bobj|300579|这将打印"CC"。|300580|然后，您将赋值给obj，它的类型为Base，因此运行可以接受int+(来自int()操作符的i+%2B+i)的构造函数，该构造函数输出"A"：|300581|obj+=+obj%2Bobj;+//+Assignment+prints+"A"|300582|entityMap^0|0|0|6|7|N|3|T|1|15|4|1A|9|1X|5|0|0|4|4|0|8|3|H|4|11|5|1A|5|0|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]|$I|15|J|16|K|L]|$I|17|J|18|K|L]|$I|19|J|1A|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1C|8|@$I|1D|J|1E|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1F|8|@$I|1G|J|1H|K|L]|$I|1I|J|1J|K|L]|$I|1K|J|1L|K|L]|$I|1M|J|1N|K|L]]|9|@]|A|$]]|$1|S|3|T|5|D|7|1O|8|@]|9|@]|A|$E|F]]|$1|U|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]]|V|$]]

When you construct the object, you get the first "A":

<pre><code> Base obj;
</code></pre>

When you specify to add <code>obj+obj</code>, the compiler needs to figure out a way to use <code>+</code> on <code>obj</code>. Since you didn't override an <code>operator+</code> for <code>Base</code>, the conversion to <code>int()</code> gets called for each side of the equation:

<pre><code>obj+obj
</code></pre>

This prints <code>"CC"</code>.

Then, you assign to <code>obj</code>, which is of type <code>Base</code>, so the constructor which can accept an int (<code>i + i</code> from the <code>int()</code> operator) is run, which prints "A":

<pre><code>obj = obj+obj; // Assignment prints "A"
</code></pre>

blocks|key|300637|text|首先，这一行：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|300638|Base+obj;|code-block|syntax|javascript|300639|default+-通过选择接受整数的构造函数来构造对象obj，默认值为1。这负责将第一个A打印到标准输出。|offset|length|style|CODE|300640|然后，这个表达式：|300641|obj+%2B+obj|300642|需要选择一个可行的operator+%2B重载。在本例中，由于obj具有到int的用户定义转换，因此选择了内置的operator+%2B，并且两个参数都被转换为int。这负责将两个C打印到标准输出。|300643|然后，对中的obj进行赋值：|300644|obj+=+obj+%2B+obj|300645|需要为Base调用隐式生成的operator+=。隐式生成的operator+=有签名：|300646|Base&+operator+=+(Base+const&);|300647|这意味着等号右侧的表达式(类型为int+)必须转换为从中分配obj的临时Base对象(隐式生成的operator+=的引用参数绑定到此临时对象)。|300648|但是，从int创建这个临时对象需要调用Base的转换构造，该构造再次接受int，负责将第二个A输出到标准输出。|300649|entityMap^0|0|0|R|3|Z|1|18|1|0|0|0|9|A|T|3|Z|3|1I|A|24|3|2E|1|0|6|3|0|0|3|4|E|A|U|A|0|0|G|3|U|3|10|4|1C|A|0|4|3|J|4|10|3|1A|1|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|18|8|@$I|19|J|1A|K|L]|$I|1B|J|1C|K|L]|$I|1D|J|1E|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1F|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|1G|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|1H|8|@$I|1I|J|1J|K|L]|$I|1K|J|1L|K|L]|$I|1M|J|1N|K|L]|$I|1O|J|1P|K|L]|$I|1Q|J|1R|K|L]|$I|1S|J|1T|K|L]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1U|8|@$I|1V|J|1W|K|L]]|9|@]|A|$]]|$1|U|3|V|5|D|7|1X|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1Y|8|@$I|1Z|J|20|K|L]|$I|21|J|22|K|L]|$I|23|J|24|K|L]]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|25|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|26|8|@$I|27|J|28|K|L]|$I|29|J|2A|K|L]|$I|2B|J|2C|K|L]|$I|2D|J|2E|K|L]]|9|@]|A|$]]|$1|12|3|13|5|6|7|2F|8|@$I|2G|J|2H|K|L]|$I|2I|J|2J|K|L]|$I|2K|J|2L|K|L]|$I|2M|J|2N|K|L]]|9|@]|A|$]]|$1|14|3|-4|5|6|7|2O|8|@]|9|@]|A|$]]]|15|$]]

First, this line:

<pre><code>Base obj;
</code></pre>

Default-constructs object <code>obj</code> by picking the constructor that accepts an integer, with default value <code>1</code>. This is responsible for the first <code>A</code> being printed to the standard output.

Then, this expression:

<pre><code>obj + obj
</code></pre>

Requires picking a viable overload of <code>operator +</code>. In this case, since <code>obj</code> has a user-defined conversion to <code>int</code>, the built-in <code>operator +</code> is picked, and both arguments are converted to <code>int</code>. This is responsible for the two <code>C</code>s being printed to the standard output.

Then, the assignment to <code>obj</code> in:

<pre><code>obj = obj + obj
</code></pre>

Needs to invoke the implicitly generated <code>operator =</code> for <code>Base</code>. The implicitly generated <code>operator =</code> has signature:

<pre><code>Base&amp; operator = (Base const&amp;);
</code></pre>

This means that the expression on the right side of the equal sign, which is of type <code>int</code>, must be converted into a temporary <code>Base</code> object from which <code>obj</code> is assigned (the reference parameter of the implicitly-generated <code>operator =</code> is bound to this temporary). 

But the creation of this temporary from an <code>int</code> in turn requires invoking the converting construction of <code>Base</code> that accepts an <code>int</code> again, which is responsible for the second <code>A</code> being printed to the standard output.

blocks|key|300678|text|obj+=+obj%2Bobj;
++++++%5E%5E%5E--------obj+converted+to+int+here
++++++++++%5E%5E%5E----obj+converted+to+int+here
%5E%5E%5E%5E%5E------------Base(int)+ctor+and+default+operator=+called+here|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|300679|重载强制转换运算符通常不是一个好主意，除非您了解成本，并知道在特定情况下收益大于收益。|unstyled|300680|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>obj = obj+obj;
 ^^^--------obj converted to int here
 ^^^----obj converted to int here
^^^^^------------Base(int) ctor and default operator= called here
</code></pre>

Overloading cast operators is not generally a good idea unless you understand the costs and know for a fact that the benefits in your specific case outweigh them.

blocks|key|300708|text|第一个A来自|type|unstyled|depth|inlineStyleRanges|entityRanges|data|300709|Base+obj;|offset|length|style|CODE|300710|这两个C来自于将obj%2Bobj中的obj转换为int，因为您没有重载operator+%2B。|300711|最后一个A来自从结果int到obj的obj+=转换。|300712|entityMap^0|0|0|9|0|8|7|N|3|Y|A|0|A|3|E|3|I|5|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@$D|S|E|T|F|G]|$D|U|E|V|F|G]|$D|W|E|X|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|Y|8|@$D|Z|E|10|F|G]|$D|11|E|12|F|G]|$D|13|E|14|F|G]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|M|$]]

The first A comes from

<code>Base obj;</code>

The two Cs come from converting obj in <code>obj+obj</code> to <code>int</code> as you didn't overload the <code>operator +</code>.

The last A comes from <code>obj =</code> conversion of the resulting <code>int</code> to <code>obj</code>.

Why does the below C++ program output "ACCA"? Why is <code>operator int()</code> called twice?

<pre><code>#include "stdafx.h"
#include &lt;iostream&gt;

using namespace std;

class Base {
public:
 Base(int m_var=1):i(m_var){
 cout&lt;&lt;"A";
 }
 Base(Base&amp; Base){
 cout&lt;&lt;"B";
 i=Base.i;
 }
 operator int() {
 cout&lt;&lt;"C";
 return i;
 }
private:
 int i;
};

int main()
{
 Base obj;
 obj = obj+obj;
 return 0;
}
</code></pre>

C++ operator overloading

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

为什么下面的C++程序会输出"ACCA"？为什么operator int()会被调用两次？#include "stdafx.h"#include <iostream>using namespace std;class Base {public: Base(int m_var=1):i(m_var){ ...

问C++运算符重载
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++运算符重载EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++运算符重载
EN