blocks|key|278756|text|在写这本书的时候，建议用处不大，但确实可以阻止用户编写foo()+=+42;，并期望它能持久地改变一些东西。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|278757|在使用operator[]的情况下，如果不提供返回非const引用的非const重载，这可能会有点混乱，尽管您可以通过返回const引用或代理对象而不是值来防止这种混淆。|278758|现在，这是一个糟糕的建议，因为它阻止您将结果绑定到(非const)右值引用。|278759|(正如评论中所指出的，当返回像int这样的原始类型时，问题是没有意义的，因为该语言阻止您为这种类型的rvalue赋值；我说的是更一般的情况，包括返回用户定义的类型。)|278760|entityMap^0|R|B|0|3|A|Q|5|Z|5|1P|5|0|R|5|0|F|3|1E|6|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$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|H|3|I|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|L|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|M|$]]

When that book was written, the advice was of little use, but did serve to prevent the user writing, for example, <code>foo() = 42;</code> and expecting it to change something persistent.

In the case of <code>operator[]</code>, this can be slightly confusing if you don't also provide a non-<code>const</code> overload that returns a non-<code>const</code> reference, although you can perhaps prevent that confusion by returning a <code>const</code> reference or a proxy object instead of a value.

These days, it's bad advice, since it prevents you from binding the result to a (non-<code>const</code>) rvalue reference.

(As pointed out in the comments, the question is moot when returning a primitive type like <code>int</code>, since the language prevents you from assigning to an <code>rvalue</code> of such a type; I'm talking about the more general case that includes returning user-defined types.)

blocks|key|278819|text|看看这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|278820|const+int+operator[](const+int+index)+const|code-block|syntax|javascript|278821|语句末尾的const。它描述了可以在常量上调用此方法。|offset|length|style|CODE|278822|另一方面，当你只写|278823|int&+operator[](const+int+index)|278824|它只能在非常数实例上调用，并且还提供：|278825|big_int[0]+=+10;|278826|语法。|278827|entityMap^0|0|0|5|5|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@$I|11|J|12|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|15|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|17|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

Look on that:

<pre><code>const int operator[](const int index) const
</code></pre>

the <code>const</code> on end of statement. It describe that this method can be called on constants.

In the other hand when you write only

<pre><code>int&amp; operator[](const int index)
</code></pre>

it can be called only on non-const instances and also provide:

<pre><code>big_int[0] = 10;
</code></pre>

syntax.

blocks|key|495755|text|对于原始类型(如int)，结果的常量无关紧要。对于类，它可能会改变行为。例如，您可能无法对函数的结果调用非常数方法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|495756|class+Bigint+{
++++const+C+foo()+const+{+...+}
+++++...
}

Bigint+b;
b.foo().bar();|code-block|syntax|javascript|495757|如果bar()不是C的常量成员函数，则禁止上述操作。一般来说，选择任何有意义的。|495758|entityMap^0|8|3|0|0|2|5|9|1|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]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

For primitive types (like <code>int</code>), the const-ness of the result does not matter. For classes, it might change the behaviour. For example, you might not be able to call a non-const method on the result of your function:
<pre><code>class Bigint {
 const C foo() const { ... }
 ...
}

Bigint b;
b.foo().bar();
</code></pre>
The above is forbidden if <code>bar()</code> is not a const member function of <code>C</code>.
In general, choose whichever makes sense.

blocks|key|278955|text|在数组索引运算符(operator[])的示例中，它确实起到了作用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|278956|使用|278957|int&+operator[](const+int+index)+{+/*+...+*/+}|code-block|syntax|javascript|278958|您可以使用索引直接更改数组中的条目，例如，像这样使用它：|278959|mybigint[3]+=+5;|278960|第二个是const+int+operator[](const+int)运算符，仅用于获取该值。|278961|然而，作为函数的返回值，对于像int这样的简单类型，这无关紧要。重要的是你是否返回了更复杂的类型，比如std::vector，并且不希望函数的调用者修改向量。|278962|entityMap^0|9|A|0|0|0|0|0|4|V|0|F|3|1F|B|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|V|$]]

In the example of the array-indexing operator (<code>operator[]</code>) it does make a difference.

With

<pre><code>int&amp; operator[](const int index) { /* ... */ }
</code></pre>

you can use the indexing to directly change the entry in the array, e.g. using it like this:

<pre><code>mybigint[3] = 5;
</code></pre>

The second, <code>const int operator[](const int)</code> operator is used to fetch the value only.

However, as return value from functions, for simple types like e.g. <code>int</code> it doesn't matter. When it does matter is if you are returning more complex types, say a <code>std::vector</code>, and don't want the caller of the function to modify the vector.

blocks|key|279007|text|在这里，const返回类型并不那么重要。由于int临时变量是不可修改的，因此在使用int和const+int时没有明显的区别。如果你使用一个更复杂的可以修改的对象，你会看到不同之处。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|279008|entityMap^0|4|5|15|3|19|9|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|O|8|@]|D|@]|E|$]]]|G|$]]

The <code>const</code> return type is not so important here. Since int temporaries are not modifiable, there's no observable difference in using <code>int</code> vs <code>const int</code>. You would see a difference if you used a more complex object which could be modified.

blocks|key|495931|text|顶层cv-忽略非class类型的返回类型的限定符。这意味着即使你写下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|495932|int+const+foo();|code-block|syntax|javascript|495933|返回类型为int。如果返回类型是引用，当然，const不再是顶层，而区别是：|offset|length|style|CODE|495934|int&+operator[](+int+index+);|495935|和|495936|int+const&+operator[](+int+index+)+const;|495937|是很重要的。(还要注意，在函数声明中，像上面一样，任何顶级的cv限定符也会被忽略。)|495938|这种区别也与类类型的返回值相关:如果返回T+const，则调用者不能对返回值调用非常数函数，例如：|495939|class+Test
{
public:
++++void+f();
++++void+g()+const;
};

Test+ff();
Test+const+gg();

ff().f();+++++++++++++//++legal
ff().g();+++++++++++++//++legal
gg().f();+++++++++++++//++**illegal**
gg().g();+++++++++++++//++legal|495940|entityMap^0|0|0|5|3|M|5|0|0|0|0|0|K|7|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@$I|13|J|14|K|L]|$I|15|J|16|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1A|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1B|8|@$I|1C|J|1D|K|L]]|9|@]|A|$]]|$1|W|3|X|5|D|7|1E|8|@]|9|@]|A|$E|F]]|$1|Y|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|Z|$]]

Top level cv-qualifiers on return types of non class type are ignored.
Which means that even if you write:

<pre><code>int const foo();
</code></pre>

The return type is <code>int</code>. If the return type is a reference, of course,
the <code>const</code> is no longer top level, and the distinction between: 

<pre><code>int&amp; operator[]( int index );
</code></pre>

and

<pre><code>int const&amp; operator[]( int index ) const;
</code></pre>

is significant. (Note too that in function declarations, like the above,
any top level cv-qualifiers are also ignored.)

The distinction is also relevant for return values of class type: if you
return <code>T const</code>, then the caller cannot call non-const functions on the
returned value, e.g.:

<pre><code>class Test
{
public:
 void f();
 void g() const;
};

Test ff();
Test const gg();

ff().f(); // legal
ff().g(); // legal
gg().f(); // **illegal**
gg().g(); // legal
</code></pre>

In <code>Effective C++</code> Item 03, Use const whenever possible.

<pre><code>class Bigint
{
 int _data[MAXLEN];
 //...
public:
 int&amp; operator[](const int index) { return _data[index]; }
 const int operator[](const int index) const { return _data[index]; }
 //...
};
</code></pre>

<code>const int operator[]</code> does make difference from <code>int&amp; operator[]</code>.

But what about:

<pre><code>int foo() { }
</code></pre>

and

<pre><code>const int foo() { }
</code></pre>

Seems like that they're the same.

My question is, why we use <code>const int operator[](const int index) const</code> instead of <code>int operator[](const int index) const</code> ?

Should I return const objects?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

在Effective C++项目03中，请尽可能使用常量。class Bigint{  int _data[MAXLEN];  //...public:  int& operator[](const int index) { return _data[index]; }  const int operator[](co...

问我应该返回常量对象吗？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我应该返回常量对象吗？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我应该返回常量对象吗？
EN