blocks|key|5135935|text|如果您将一个运算符修改为const，它将起作用：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5135936|operator+const+Color()+const+{
++++cout+<<+"operator+const+Color()+const+called"+<<+endl;
++++return+Color(10,+20,+30);
}|code-block|syntax|javascript|5135937|或者，您可以删除两个运算符中的一个。由于是按值返回Color，因此这两个运算符之间没有真正的区别。|5135938|entityMap^0|C|5|0|0|P|5|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

If you modify one operator to be <code>const</code>, it will work:

<pre><code>operator const Color() const {
 cout &lt;&lt; "operator const Color() const called" &lt;&lt; endl;
 return Color(10, 20, 30);
}
</code></pre>

Alternatively, you can remove one of the two operators. Since you return the <code>Color</code> by value, there's no real difference between the two operators.

blocks|key|2921596|text|这是因为在您的第二个示例中，您将const添加到一个对象，而不是指针(在第一个示例中)。在重载解析阶段，const和object会使编译产生混淆，根据c%2B%2B标准，这两者是一样好的(object和const+object)。编译器不会试图在这里聪明地选择一个而不是另一个。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2921597|但是在指针和常量指针中(引用也是有效的)，编译器可以相应地从这两个重载候选对象中进行选择，这是您的第一种情况。|2921598|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

That is because in your second example you were adding const to a object , not pointer(in your first case). And const with object make compile confuse in overload resolution stage, those two are as good as each other(object vs const object) according to c++ standard. compiler won't be try to smart here and choose one over another. 

But in pointer vs const pointer (reference works too), compile can choose from those two overload candiate accordingly,which is your first case.

blocks|key|2921808|text|问题是，你的两个例子是不等价的。第一个返回两个不同的类型，编译器可以很容易地从中选择，一个指向可变数据的指针和一个指向常量数据的指针。这将是不同的，如果它是一个指针和一个常量指针(这意味着你不能改变返回的指针所指向的位置，而不是不改变指向数据的指针)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2921809|class+Test
{
++++operator+char+*+const();
++++operator+char+*();
};|code-block|syntax|javascript|2921810|这将等同于您的第二个示例，并引入了相同的歧义，因为编译器无法决定选择哪一个，因为两者都返回相同的类型，一个是const限定的，另一个不是。|2921811|这可以通过基于对象的常量重载来解决：|2921812|class+ColorWrapper
{
++++operator+const+Color()+const;
++++operator+Color();
};|2921813|2921814|因此，您可以根据源对象的常量进行重载。但是，您不能像现在所希望的那样，简单地基于目标对象的常量来进行重载。|2921815|这一切都归结为考虑对象和对象可能间接引用的数据之间的差异，在实践中，对象本身表现为常量指针和指向常量数据的指针之间的差异。|2921816|2921817|我想在这里实现的是防止用户直接更改颜色|blockquote|2921818|2921819|2921820|这样就完全不需要任何重载了。只要返回const版本即可。用户不能直接更改返回的颜色，他只能复制和更改副本。|2921821|cw.set(red);++++//nope,+return+color+is+constant
Color+col+=+cw;+//copy+returned+color+into+col
col.set(green);+//fine,+since+we're+not+working+on+the+returned+color,+but+on+col

const+Color+c_col+=+cw;+//use+this+if+you+don't+want+c_col+to+be+modified,+
++++++++++++++++++++++++//doesn't+have+anything+to+do+with+returned+color,+though|2921822|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|15|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|16|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|18|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|19|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1A|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]|$1|S|3|T|5|U|7|1C|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1F|8|@]|9|@]|A|$]]|$1|Z|3|10|5|D|7|1G|8|@]|9|@]|A|$E|F]]|$1|11|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|12|$]]

The thing is, that your two examples are not equivalent. The first returns two different types from which the compiler can easily choose, a pointer to mutable data and a pointer to constant data. It would be different, was it a pointer vs a constant pointer (which would mean you cannot change where the returned pointer points, in contrast to not changing the pointed to data):

<pre><code>class Test
{
 operator char * const();
 operator char *();
};
</code></pre>

which would be equivalent to your second example and introduce the same ambiguity, since the compiler cannot decide which one to choose, as both return the same type, one const-qualified and the other not.

This could be solved by overloading based on the constness of the object:

<pre><code>class ColorWrapper
{
 operator const Color() const;
 operator Color();
};
</code></pre>

But this won't buy you anything here, since you return a new object by value anyway, so you can always return the const version, and also the appropriate version would be chosen based on the source object's constness and not the destination obejct's constness (thus call the non-const version in both cases), which doesn't seem what you want.

So you can overload based on the constness of the source object. But you cannot, as you want to now, overload simply based on the constness of the destination object.

This all reduces down to thinking about the difference between an object and the data the object may inderectly refer to, which in practice presents itself as the difference between a constant pointer and a pointer to constant data.

<blockquote>
 What I'm trying to achieve here is to prevent the user from changing
 the color directly
</blockquote>

Then there's absolutely no need for any overloading. Just return the const version. The user cannot change the returned color directly, he can only copy it and change the copy.

<pre><code>cw.set(red); //nope, return color is constant
Color col = cw; //copy returned color into col
col.set(green); //fine, since we're not working on the returned color, but on col

const Color c_col = cw; //use this if you don't want c_col to be modified, 
 //doesn't have anything to do with returned color, though
</code></pre>

blocks|key|5045744|text|你之所以观察到这个问题，是因为这里基本上有两个不同的案例。我认为展示这里发生的事情最简单的方法是修改一下你的第一个例子：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5045745|class+Test
{
++++operator+char*+const()+{
++++++++return+"operator+char*+()+called";
++++}

++++operator+char*()+{
++++++++return+const_cast<char*>+("operator+char*()+called");
++++++++//+a+really+ugly+hack+for+demonstration+purposes
++++}
};|code-block|syntax|javascript|5045746|现在您的情况与第二个示例中的情况完全相同。你基本上返回了一个拷贝(指针)和一个常量拷贝，这就是为什么它们在重载解析中搞砸了。|5045747|您最初的第一个示例运行良好，因为这些转换操作符转换为两种不同类型的指针(const+char和char)。我希望这有助于理解这里的区别。|offset|length|style|CODE|5045748|顺便说一句，我个人认为从方法返回const副本没有多大意义。它不会对用户做任何更改，只会混淆类接口。|5045749|entityMap^0|0|0|0|10|A|1B|4|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|V|8|@$K|W|L|X|M|N]|$K|Y|L|Z|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

You observe that problem because you basically have 2 different cases here. I think that the easiest way to present what is happening here is to modify a bit your first example:

<pre><code>class Test
{
 operator char* const() {
 return "operator char* () called";
 }

 operator char*() {
 return const_cast&lt;char*&gt; ("operator char*() called");
 // a really ugly hack for demonstration purposes
 }
};
</code></pre>

Now you have exactly the same situation as in the second example. You basically return a copy (of a pointer) and a const copy and that is why they mess up in overload resolution.

Your original first example works fine because those conversion operators convert to pointers of 2 different types (<code>const char</code> and <code>char</code>). I hope that helps to understand the difference here.

BTW, I personally believe that there is no much sense in returning a const copy from a method. It does not change anything to the user and only obfuscates the class interface.

Why do the following two usecases behave differently?

An example for a built-in type:

<pre><code>class Test
{
 operator const char*() {
 return "operator const char*() called";
 }

 operator char*() {
 return const_cast&lt;char*&gt; ("operator char*() called");
 // a really ugly hack for demonstration purposes
 }
};

Test test;
const char *c_ch = test; // -&gt; operator const char*() called
char *ch = test; // -&gt; operator char*() called
</code></pre>

Okay, everything works as it should. No, let's try it with a user-defined type:

<pre><code>class ColorWrapper
{
 operator const Color() {
 cout &lt;&lt; "operator const Color() called" &lt;&lt; endl;
 return Color(10, 20, 30);
 }

 operator Color() {
 cout &lt;&lt; "operator Color() called" &lt;&lt; endl;
 return Color(11, 22, 33);
 }
};

ColorWrapper cw;
const Color c_col = cw;
Color col = cw;
</code></pre>

The situation looks identical; but now, GCC starts complaining:

<pre><code>error: conversion from 'ColorWrapper' to 'const Color' is ambiguous
error: conversion from 'ColorWrapper' to 'Color' is ambiguous
</code></pre>

Am I missing something? What I'm trying to achieve here is to prevent the user from changing the color directly. If they want to change it, they must do it via the wrapper class.

Overloading typecasting operators: const & non-const

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

为什么下面两个用例的行为不同？内置类型的示例：class Test{    operator const char*() {        return "operator const char*() called";    }    operator char*() {        return const_cas...

问重载类型转换运算符:常量和非常量
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问重载类型转换运算符:常量和非常量EN