blocks|key|354980|text|只有当您转换的变量最初是非const时，const_cast才是安全的。例如，如果您有一个接受const+char+*参数的函数，并且您传入了一个可修改的char+*，那么将该参数const_cast回char+*并对其进行修改是安全的。但是，如果原始变量实际上是const，那么使用const_cast将导致未定义的行为。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|354981|void+func(const+char+*param,+size_t+sz,+bool+modify)
{
++++if(modify)
++++++++strncpy(const_cast<char+*>(param),+sz,+"new+string");
++++printf("param:+%25s\n",+param);
}

...

char+buffer[16];
const+char+*unmodifiable+=+"string+constant";
func(buffer,+sizeof(buffer),+true);++//+OK
func(unmodifiable,+strlen(unmodifiable),+false);+//+OK
func(unmodifiable,+strlen(unmodifiable),+true);++//+UNDEFINED+BEHAVIOR|code-block|syntax|javascript|354982|entityMap^0|D|5|K|A|1B|C|25|6|2I|A|2T|6|3O|5|3Y|A|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]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|L|$]]

<code>const_cast</code> is safe only if you're casting a variable that was originally non-<code>const</code>. For example, if you have a function that takes a parameter of a <code>const char *</code>, and you pass in a modifiable <code>char *</code>, it's safe to <code>const_cast</code> that parameter back to a <code>char *</code> and modify it. However, if the original variable was in fact <code>const</code>, then using <code>const_cast</code> will result in undefined behavior.

<pre><code>void func(const char *param, size_t sz, bool modify)
{
 if(modify)
 strncpy(const_cast&lt;char *&gt;(param), sz, "new string");
 printf("param: %s\n", param);
}

...

char buffer[16];
const char *unmodifiable = "string constant";
func(buffer, sizeof(buffer), true); // OK
func(unmodifiable, strlen(unmodifiable), false); // OK
func(unmodifiable, strlen(unmodifiable), true); // UNDEFINED BEHAVIOR
</code></pre>

blocks|key|358345|text|我很难相信这是你能找到的关于const_cast的唯一信息。引用自second+Google+hit|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|358346|358347|如果您丢弃已显式声明为const的对象的常量，并尝试修改它，则结果是未定义的。|blockquote|358348|358349|但是，如果您丢弃未显式声明为const的对象的常量，则可以安全地修改它。|358350|entityMap|0|LINK|mutability|MUTABLE|url|http://publib.boulder.ibm.com/infocenter/lnxpcomp/v7v91/index.jsp?topic=/com.ibm.vacpp7l.doc/language/ref/clrc05keyword_const_cast.htm^0|X|H|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|-4|5|6|7|W|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|X|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|10|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

I find it hard to believe that that's the only information you could find about const_cast. Quoting from the <a href="http://publib.boulder.ibm.com/infocenter/lnxpcomp/v7v91/index.jsp?topic=/com.ibm.vacpp7l.doc/language/ref/clrc05keyword_const_cast.htm" rel="noreferrer">second Google hit</a>:

<blockquote>
 If you cast away the constness of an
 object that has been explicitly
 declared as const, and attempt to
 modify it, the results are undefined.
 
 However, if you cast away the
 constness of an object that has not
 been explicitly declared as const, you
 can modify it safely.
</blockquote>

blocks|key|355746|text|如果你开始修改编译器认为是常量的东西，你正在破坏任何线程安全的机会。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|355747|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|$]]

You're destroying any chance at thread-safety, if you start modifying things that the compiler thought were const.

blocks|key|353696|text|亚当说的话。const_cast可以提供帮助的另一个示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|353697|struct+sample+{
++++T&+getT()+{+
++++++++return+const_cast<T&>(static_cast<const+sample*>(this)->getT());+
++++}

++++const+T&+getT()+const+{+
+++++++/*+possibly+much+code+here+*/
+++++++return+t;+
++++}

++++T+t;
};|code-block|syntax|javascript|353698|我们首先将const添加到this指向的类型，然后调用getT的const版本，然后从返回类型中删除const，这是有效的，因为t必须是非常量(否则，无法调用getT的非常量版本)。如果你有一个很大的函数体，并且你想避免多余的代码，这是非常有用的。|offset|length|style|CODE|353699|entityMap^0|0|0|D|4|R|4|1S|1|27|4|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]|$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|N|$]]

What Adam says. Another example where const_cast can be helpful:

<pre><code>struct sample {
 T&amp; getT() { 
 return const_cast&lt;T&amp;&gt;(static_cast&lt;const sample*&gt;(this)-&gt;getT()); 
 }

 const T&amp; getT() const { 
 /* possibly much code here */
 return t; 
 }

 T t;
};
</code></pre>

We first add const to the type <code>this</code> points to, then we call the const version of <code>getT</code>, and then we remove const from the return type, which is valid since <code>t</code> must be non-const (otherwise, the non-const version of <code>getT</code> couldn't have been called). This can be very useful if you got a large function body and you want to avoid redundant code.

blocks|key|358373|text|我可以想到两种情况，const_cast是安全和有用的(可能还有其他有效的情况)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|358374|一种是当你有一个常量实例、引用或指针，并且你想要传递一个不是常量正确的API的指针或引用，但是你确定不会修改这个对象。您可以const_cast指针并将其传递给API，相信它不会真正改变任何事情。例如：|358375|void+log(char*+text);+++//+Won't+change+text+--+just+const-incorrect

void+my_func(const+std::string&+message)
{
++++log(const_cast<char*>(&message.c_str()));
}|code-block|syntax|javascript|358376|另一种是如果你使用的是一个没有实现'mutable‘的旧编译器，并且你想创建一个逻辑常量而不是逐位常量的类。您可以在const方法中使用const_cast+'this‘并修改类的成员。|358377|class+MyClass
{
++++char+cached_data[10000];+//+should+be+mutable
++++bool+cache_dirty;++++++++//+should+also+be+mutable

++public:

++++char+getData(int+index)+const
++++{
++++++++if+(cache_dirty)
++++++++{
++++++++++MyClass*+thisptr+=+const_cast<MyClass*>(this);
++++++++++update_cache(thisptr->cached_data);
++++++++}
++++++++return+cached_data[index];
++++}
};|358378|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I can think of two situations where const_cast is safe and useful (there may be other valid cases).

One is when you have a const instance, reference, or pointer, and you want to pass a pointer or reference to an API that is not const-correct, but that you're CERTAIN won't modify the object. You can const_cast the pointer and pass it to the API, trusting that it won't really change anything. For example:

<pre><code>void log(char* text); // Won't change text -- just const-incorrect

void my_func(const std::string&amp; message)
{
 log(const_cast&lt;char*&gt;(&amp;message.c_str()));
}
</code></pre>

The other is if you're using an older compiler that doesn't implement 'mutable', and you want to create a class that is logically const but not bitwise const. You can const_cast 'this' within a const method and modify members of your class.

<pre><code>class MyClass
{
 char cached_data[10000]; // should be mutable
 bool cache_dirty; // should also be mutable

 public:

 char getData(int index) const
 {
 if (cache_dirty)
 {
 MyClass* thisptr = const_cast&lt;MyClass*&gt;(this);
 update_cache(thisptr-&gt;cached_data);
 }
 return cached_data[index];
 }
};
</code></pre>

blocks|key|3139507|text|简短的回答是不，这是不安全的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3139508|长长的答案是，如果你知道足够的知识来使用它，那么它应该是安全的。|3139509|当你进行造型时，你实际上是在说，“我知道一些编译器不知道的事情。”对于const_cast，您所说的是，“即使这个方法接受非常数引用或指针，我知道它不会改变传递它的参数。”|3139510|因此，如果您确实知道您在使用强制转换时声称要知道的内容，那么使用它是很好的。|3139511|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

The short answer is no, it's not safe.

The long answer is that if you know enough to use it, then it should be safe.

When you're casting, what you are essentially saying is, "I know something the compiler doesn't know." In the case of const_cast, what you are saying is, "Even though this method takes in a non-const reference or pointer, I know that it won't change the parameter I pass it."

So if you do actually know what you are claiming to know in using the cast, then it's fine to use it.

I can't find much information on <code>const_cast</code>. The only info I could find (on Stack Overflow) is:

<blockquote>
 The <code>const_cast&lt;&gt;()</code> is used to add/remove const(ness) (or volatile-ness) of a variable.
</blockquote>

This makes me nervous. Could using a <code>const_cast</code> cause unexpected behavior? If so, what?

Alternatively, when is it okay to use <code>const_cast</code>?

Is const_cast safe?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我在const_cast上找不到太多信息。我能找到的唯一信息(在堆栈溢出上)是： const_cast<>()用于添加/删除变量的常量(或易失性)。这让我很紧张。使用const_cast会导致意外的行为吗？如果是这样，是什么？或者，什么时候可以使用const_cast

问const_cast安全吗？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问const_cast安全吗？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问const_cast安全吗？
EN