blocks|key|1498787|text|嗯。常量正确性更像是一种样式/错误检查，而不是一种优化。一个全能的优化编译器将跟踪变量的用法，并可以检测变量是否为有效常量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1498788|更重要的是，编译器不能指望你告诉它真相--你可能会在一个它不知道的库函数中抛弃const。|1498789|所以，常量正确性是一个值得追求的目标，但它不会告诉编译器任何它自己不会弄明白的事情，假设一个好的优化编译器。|1498790|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Meh. Const-correctness is more of a style / error-checking thing than an optimisation. A full-on optimising compiler will follow variable usage and can detect when a variable is effectively const or not.

Added to that, the compiler cannot rely on you telling it the truth - you could be casting away the const inside a library function it doesn't know about.

So yes, const-correctness is a worthy thing to aim for, but it doesn't tell the compiler anything it won't figure out for itself, assuming a good optimising compiler.

blocks|key|1713905|text|如果优化器真的在const声明中投入了大量资源，我会感到惊讶。有很多代码最终会抛弃const，这将是一个非常不计后果的优化器，它依赖于程序员的声明来假设何时状态可能会发生变化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1713906|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|$]]

I would be surprised if the optimizer actually puts much stock into a const declaration. There is a lot of code that will end up casting const-ness away, it would be a very reckless optimizer that relied on the programmer declaration to assume when the state may change.

blocks|key|1498904|text|const是直接优化的最明显的一点是将参数传递给函数。通常重要的是要确保函数不会修改数据，因此函数签名的唯一实际选择是：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1498905|void+f(Type+dont_modify);+//+or
void+f(Type+const&+dont_modify);|code-block|syntax|javascript|1498906|当然，这里真正的魔力是传递一个引用，而不是创建对象的(昂贵的)副本。但是如果引用没有被标记为const，这将削弱该函数的语义，并产生负面影响(例如使错误跟踪变得更加困难)。因此，const在这里实现了优化。|1498907|/EDIT:实际上，一个好的编译器可以分析函数的控制流，确定它不修改参数，并进行优化(传递引用而不是副本)本身。这里的const仅仅是对编译器的帮助。然而，由于C%2B%2B有一些非常复杂的语义，而且这种控制流分析对于大函数来说可能非常昂贵，因此我们可能不应该依赖编译器来实现这一点。有谁有任何数据支持我/证明我错了吗？|1498908|/EDIT2:是的，一旦自定义复制构造函数开始发挥作用，它就变得更加棘手，因为不幸的是，编译器在这种情况下不允许省略对它们的调用。|1498909|entityMap^0|0|5|0|0|1A|5|2H|5|0|1N|5|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|14|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|R|$]]

The most obvious point where <code>const</code> is a direct optimization is in passing arguments to a function. It's often important to ensure that the function doesn't modify the data so the only real choices for the function signature are these:

<pre><code>void f(Type dont_modify); // or
void f(Type const&amp; dont_modify);
</code></pre>

Of course, the real magic here is passing a reference rather than creating an (expensive) copy of the object. But if the reference weren't marked as <code>const</code>, this would weaken the semantics of this function and have negative effects (such as making error-tracking harder). Therefore, <code>const</code> enables an optimization here.

/EDIT: actually, a good compiler can analyze the control flow of the function, determine that it doesn't modify the argument and make the optimization (passing a reference rather than a copy) itself. <code>const</code> here is merely a help for the compiler. However, since C++ has some pretty complicated semantics and such control flow analysis can be very expensive for big functions, we probably shouldn't rely on compilers for this. Does anybody have any data to back me up / prove me wrong?

/EDIT2: and yes, as soon as custom copy constructors come into play, it gets even trickier because compilers unfortunately aren't allowed to omit calling them in this situation.

blocks|key|1713956|text|const帮助编译器进行优化，主要是因为它可以让您编写可优化的代码。除非你再加上const_cast。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1713957|entityMap^0|0|5|14|A|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

<code>const</code> helps compilers optimize mainly because it makes you write optimizable code. Unless you throw in <code>const_cast</code>.

blocks|key|1713995|text|常量正确性作为文档也很有用。如果一个函数或参数被列为const，我就不需要担心我的代码中的值会发生变化(除非团队中的其他人非常顽皮)。不过，我不确定如果它没有内置到库中，它是否真的值得。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1713996|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|$]]

const-correctness is also useful as documentation. If a function or parameter is listed as const, I don't need to worry about the value changing out from under my code (unless somebody else on the team is being very naughty). I'm not sure it would be actually worth it if it wasn't built into the library, though.

I've read all the advice on const-correctness in C++ and that it is important (in part) because it helps the compiler to optimize your code. What I've never seen is a good explanation on how the compiler uses this information to optimize the code, not even the good books go on explaining what happens behind the curtains. 

For example, how does the compiler optimize a method that is declared const vs one that isn't but should be. What happens when you introduce mutable variables? Do they affect these optimizations of const methods?

Constants and compiler optimization in C++

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我已经阅读了C++中关于常量正确性的所有建议，它很重要(部分)，因为它有助于编译器优化您的代码。我从来没有见过关于编译器如何使用这些信息来优化代码的很好的解释，即使是好书也没有解释幕后发生的事情。例如，编译器如何优化声明为const的方法，而不是声明为const但应该为const的方法。当引入可变变量时会发生什么？它们...

问C++中的常量和编译器优化
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++中的常量和编译器优化EN