blocks|key|3983335|text|obj是对const对象的引用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3983336|不存在“非常数引用”这样的东西，因为引用在创建后不能被更改为引用其他对象。|3983337|entityMap^0|0|3|5|5|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

<code>obj</code> is a reference to a <code>const</code> object.

There is no such thing as a "non-const reference", since a reference cannot be changed to refer to something else after it has been created.

blocks|key|5597924|text|没有所谓的“非常量”引用，也就是说，引用总是绑定到同一个对象，并且没有办法改变这一点。"const+type&“表示引用const类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5597925|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|$]]

There is no such thing as a "non-const" reference, that is, a reference is always bound to the same object and there is no way to change that. "const type&amp;" means reference to const type.

blocks|key|202692|text|它被称为常量引用。您拥有对已传递数据的“引用访问”权限，但不能对其进行修改。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|202693|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|$]]

It's called a const reference. You have a ' referential access ' to data that's passed but you cannot modify it.

blocks|key|3983574|text|如果没有const，您将无法向该函数发送const对象。因此，添加const始终是积极的。尤其是当你为许多用户创建函数的时候。典型的例子是setters函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3983575|x->setXsth(sth&+obj)++++++++++++++//+works+only+with++non-const+object.+
x->setXsth(const+sth&+obj)++++++++//works+with++const+object+and+non-const.|code-block|syntax|javascript|3983576|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Without const you will be not able to send a const object to that function. So it is always a positive to add const. especially when you are creating function for many users. Classic examples are setters functions. 

<pre><code>x-&gt;setXsth(sth&amp; obj) // works only with non-const object. 
x-&gt;setXsth(const sth&amp; obj) //works with const object and non-const.
</code></pre>

blocks|key|3983595|text|obj是对const+base的引用，因此它意味着您不允许更改引用的对象。它可以写成|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3983596|func(const+base&+obj)|code-block|syntax|javascript|3983597|或|3983598|func(base+const+&+obj)|3983599|使用right-left规则来读取这类声明类型，对于这个简单的示例，只需从右侧读取即可。更多信息请看这里：|3983600|http://www.codeproject.com/KB/cpp/complex_declarations.aspx|offset|length|3983601|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|0|0|1N|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Z|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|11|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|12|8|@]|9|@$O|13|P|14|1|15]]|A|$]]|$1|Q|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|N]]]]

obj is a reference to const base, so it means you are not allowed to change referenced object. It can be written as

<pre><code>func(const base&amp; obj)
</code></pre>

or

<pre><code>func(base const &amp; obj)
</code></pre>

Use right-left rule for reading such declarations types, for this simple example just read it from the right. More on that here:

<a href="http://www.codeproject.com/KB/cpp/complex_declarations.aspx" rel="nofollow">http://www.codeproject.com/KB/cpp/complex_declarations.aspx</a>

blocks|key|3983511|text|obj是对传递给func()的参数中的对象(无论对象是常量还是非常量)的常量引用|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3983512|如果你这样写：func(B);|3983513|这意味着您不能在函数func()内更改B的内容|3983514|(其中func(const+base&+obj))|3983515|entityMap^0|0|3|8|6|0|7|8|0|A|6|J|1|0|3|L|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|L|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|M|$]]

<code>obj</code> is a constant reference to an object (wether the object is const or non const) passed in argument to <code>func()</code>

if you write : <code>func(B);</code>

this means that you cannot change the content of <code>B</code> inside the function <code>func()</code>

(where <code>func(const base&amp; obj)</code>)

blocks|key|1223522|text|有些不请自来的回答/观点:+const修饰符修改其左侧的任何内容，除了您正在使用的一个结构(在这种情况下，它修改紧邻右侧的任何内容)。我发现总是把const放在我想要修改的东西的右边，然后从右向左阅读语句会更容易一些。也许这不是做事情的最好方法，但它能帮助我保持思路清晰。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1223523|示例：|1223524|//+these+two+statements+are+equivalent
const+int+x+=+5;+//+special+case+usage
int+const+x+=+5;

//+using+the+LHS+syntax+makes+multiple+consts+easier+to+understand
int+const+y+=+6;
int+const+*+const+x+=+&y;+//+x+is+a+const+pointer+to+const+int

//+const+can+apply+to+pointers+but+not+to+references
int+const+&+const+z+=+y;+//+redundant,+references+are+always+const|code-block|syntax|javascript|1223525|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Somewhat unsolicited answer/viewpoint: The const modifier modifies whatever is on its left-hand-side, except for the one construction that you're using (in which case it modifies whatever is immediately to the right). I find it easier to always stick const immediately on the right of whatever I want to modify, and read the statement right-to-left. Maybe this isn't the best way to do things, but it helps me to keep it straight.

Examples:

<pre><code>// these two statements are equivalent
const int x = 5; // special case usage
int const x = 5;

// using the LHS syntax makes multiple consts easier to understand
int const y = 6;
int const * const x = &amp;y; // x is a const pointer to const int

// const can apply to pointers but not to references
int const &amp; const z = y; // redundant, references are always const
</code></pre>

blocks|key|3983633|text|正如其他答案所说，obj是对const+base对象的引用。然而，这并不意味着它引用的对象具有确切的base类型，或者它引用的对象是const，只是func不能通过引用的修改obj。例如：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|BOLD|entityRanges|data|3983634|struct+derived+:+base+{+...+};
derived+d;
func(d);|code-block|syntax|javascript|3983635|是合法的，并且：|3983636|bool+other_func(const+base&+b,+other_object&+o)+{
+++base+b_copy+=+b;
+++o.foo();
+++return+b_copy+==+b;
}|3983637|如果o具有对b+(或其中的某些内容)的内部非常数引用，并且o.foo()修改b，则可能返回false。这对于像这样的函数具有实际意义|3983638|std::string::operator=(const+std::string&+other);|3983639|一个幼稚的实现可能会对my_str+=+my_str造成错误的影响。|3983640|entityMap^0|9|3|E|A|1E|4|1U|5|22|4|2F|3|2D|9|0|0|0|8|0|0|0|1U|2|1|6|1|T|7|12|1|19|5|0|0|0|Y|B|F|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|D]]|E|@]|F|$]]|$1|G|3|H|5|I|7|1C|8|@]|E|@]|F|$J|K]]|$1|L|3|M|5|6|7|1D|8|@$9|1E|A|1F|B|D]]|E|@]|F|$]]|$1|N|3|O|5|I|7|1G|8|@]|E|@]|F|$J|K]]|$1|P|3|Q|5|6|7|1H|8|@$9|1I|A|1J|B|D]|$9|1K|A|1L|B|C]|$9|1M|A|1N|B|C]|$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]|$9|1S|A|1T|B|C]]|E|@]|F|$]]|$1|R|3|S|5|I|7|1U|8|@]|E|@]|F|$J|K]]|$1|T|3|U|5|6|7|1V|8|@$9|1W|A|1X|B|D]|$9|1Y|A|1Z|B|C]]|E|@]|F|$]]|$1|V|3|-4|5|6|7|20|8|@]|E|@]|F|$]]]|W|$]]

As other answers have said, <code>obj</code> is a reference to a <code>const base</code> object. However, that doesn't mean the object it refers to either has exactly the <code>base</code> type, or that the object it refers to is <code>const</code>, just that <code>func</code> can't modify <code>obj</code> through that reference. For example:

<pre><code>struct derived : base { ... };
derived d;
func(d);
</code></pre>

is legal, and:

<pre><code>bool other_func(const base&amp; b, other_object&amp; o) {
 base b_copy = b;
 o.foo();
 return b_copy == b;
}
</code></pre>

may return <code>false</code> if <code>o</code> has an internal non-const reference to <code>b</code> (or something inside it) and <code>o.foo()</code> modifies <code>b</code>. This has practical implications for functions like

<pre><code>std::string::operator=(const std::string&amp; other);
</code></pre>

where a naive implementation might do the wrong thing for <code>my_str = my_str</code>.

If there is something like below in code:

<pre><code>func(const base&amp; obj)
</code></pre>

what does the const semantics mean? What is constant here ? Is obj a <code>const reference to a non-const object</code> or a <code>non-const reference to a const object</code>?

C++ const semantics for a reference

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

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

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

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

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

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

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

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

如果代码中有类似下面的内容：func(const base& obj)常量语义是什么意思？这里的常数是什么？obj是const reference to a non-const object还是non-const reference to a const object

问引用的C++常量语义
EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问引用的C++常量语义EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问引用的C++常量语义
EN