blocks|key|998079|text|这是未定义的行为，因为delete[]调用了错误的析构函数。然而，wchar_t和char是PODs，所以它们没有专用的析构函数，delete[]所做的就是调用堆实现来释放指针。因此，它最有可能工作，没有字节丢失。但严格地说，它仍然是未定义的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|998080|entityMap^0|B|8|X|7|15|4|1T|8|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]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|G|$]]

It is undefined behaviour because <code>delete[]</code> invokes the wrong destructor. However, <code>wchar_t</code> and <code>char</code> are PODs, so they have no dedicated destructor and all <code>delete[]</code> does is calling the heap implementation to free up the pointer. Therefore, it is most likely to work, no byte is lost. But strictly speaking it is still undefined.

blocks|key|2407407|text|delete[]操作符在内部使用某种形式的循环来析构数组的元素。如果元素是不同的对象，将使用不同的析构函数--这可能会导致未定义的行为。由于是wchar和char+--基本类型--它可能不会导致任何不受欢迎的行为。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2407408|警告:如果您继续阅读，后果自负！未来未定义行为的粗略描述。这仅用于教育目的。|offset|length|style|BOLD|2407409|示例1:|2407410|如果你有两个大小相同的对象，并且它们的析构函数所做的一切都是清空内存，那么同样，它可能不会导致不可靠的行为。|2407411|示例2:|2407412|但是，如果您有两个对象，其中一个类型封装了一个4字节的资源句柄，另一个对象有两个这样的元素，并且您将后者的数组强制转换为单数情况--那么您将泄漏一半的数组句柄。情况将如下所示：|2407413|..2:1%7C2FREE..|2407414|其中'2:‘表示数组的大小。在向下转换之后，编译器将生成一个delete，该delete认为数据是这样的：|2407415|..2:1FREE...|2407416|因此，在免费之后，事情看起来是这样的：|2407417|..FREE1%7C2FREE..|2407418|entityMap^0|0|0|12|0|0|4|0|0|0|4|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@$D|13|E|14|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|15|8|@$D|16|E|17|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|18|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|19|8|@$D|1A|E|1B|F|G]]|9|@]|A|$]]|$1|N|3|O|5|6|7|1C|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1D|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1E|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|1F|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|1G|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1H|8|@]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]]|10|$]]

The delete[] operator internally uses a loop of some form to destruct the elements of your array. If the elements are different objects a different destructor will be used -- which can potentially cause undefined behaviour. Since the is a wchar and a char -- primitive types -- it probably won't cause any undesireable behaviour.

WARNING: IF YOU CONTINUE READING DO SO AT YOUR OWN PERIL !! GROSS DESCRIPTIONS OF UNDEFINED BEHAVIOUR AHEAD. THIS IS FOR EDUCATIONAL PURPOSES ONLY.

Example 1: 

If you had two objects which were the same size and all their destructor did was zero out the memory then again it would probably not cause undersireable behaviour. 

Example 2:

However if you had two objects where one type encapsulated a single 4 byte handle to a resource and the other had two such elements and you casted an array of the later into the singular case -- well then you would leak half of the handles of your array. The situation would look as follows:

..2:[1|2][1|2]FREE..

where the '2:' represents the size of the array. After a downcast the compiler will generate a delete that perceived the data as so :

..2:[1][1]FREE...

therefore after the free things would look like so:

..FREE[1|2]FREE..

blocks|key|2407465|text|至少在我看来，你有一个不同于动态类型(指针指向的对象的真实类型)的静态类型(指针的类型)。在这种情况下，§5.3.5/3的第二句适用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2407466|如果要删除的对象的动态类型与其静态类型不同，则行为是未定义的(+|2407467|+)。|blockquote|2407468|2407469|2407470|编辑:由于您显然希望分配一个“原始”内存的缓冲区，而不是对象数组，因此我建议使用::operator+new而不是new[]。在这种情况下，你所做的事情是明确定义的，也给读者一个明确的意图。|offset|length|style|CODE|2407471|entityMap^0|0|0|0|0|0|14|E|1L|5|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|T|8|@]|9|@]|A|$]]|$1|H|3|-4|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|-4|5|6|7|10|8|@]|9|@]|A|$]]]|P|$]]

At least as I'd read it, you have a static type (the type of the pointer) that differs from the dynamic type (the real type of the object it points at). That being the case, the second sentence of §5.3.5/3 applies:

<blockquote>
 In the second alternative (delete array) if the dynamic type of the
 object to be deleted differs from its static type, the behavior is undefined.
</blockquote>

Edit: Since what you apparently want is to allocate a buffer of "raw" memory instead of an array of objects, I'd advise using <code>::operator new</code> instead of <code>new[]</code>. In this case, what you're doing is clearly defined, and also gives the reader a clear indication of intent.

blocks|key|2407492|text|iso14882第5.2.10.3节：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2407493|The+mapping+performed+by+reinterpret_cast+is+is+implementation+defined|offset|length|style|CODE|2407494|iso14882第5.3.5.2节：|2407495|The+value+of+the+operand+of+delete[]+shall+be+the+pointer+value+which+resulted+from+a+previous+array+new-expression|2407496|换句话说，它的实现定义了delete[]是否调用未定义的行为。躲开。|2407497|entityMap^0|0|0|1Y|0|0|0|37|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@$D|R|E|S|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|U|8|@$D|V|E|W|F|G]]|9|@]|A|$]]|$1|L|3|M|5|6|7|X|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|O|$]]

iso14882 section 5.2.10.3:

<code>The mapping performed by reinterpret_cast is is implementation defined</code>

iso14882 section 5.3.5.2:

<code>The value of the operand of delete[] shall be the pointer value which resulted from a previous array new-expression</code>

In other words, it's implementation defined whether or not the delete[] invokes undefined behaviour. Steer clear.

blocks|key|998237|text|你为什么要使用reinterpret_cast<..>？如果你正在用纯C%2B%2B写东西，那么你不需要重新解释cast。在您的例子中，您没有为对象分配内存。您正在为wchar_t分配内存。为什么不使用to字符串而使用wchar_t的数组？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|998238|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|$]]

Why are you using reinterpret_cast&lt;..>? If you are writing something in pure C++, then you don't need reinterpret cast. In your case you are not allocating the memory for a object. You are allocating the memory for wchar_t. Why don't use to string instead of array of wchar_t?

blocks|key|2407603|text|由于wchar_t和char都是内置类型，因此将调用正确的释放函数(void+operator+delete(void*+ptr))，并且不需要调用析构函数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2407604|然而，C%2B%2B+03标准规定reinterpret_cast<T1*>(T2*)的结果是未定义的(第5.2.10.7节)：|2407605|2407606|指向对象的指针可以显式转换为指向不同类型对象的指针。除了将“指向T1的指针”类型的右值转换为“指向T2的指针”类型(其中T1和T2是对象类型，并且T2的对齐要求不比T1的对齐要求更严格)并返回其原始类型产生原始指针值之外，这种指针转换的结果是未指定的。|blockquote|2407607|2407608|2407609|从实际的观点来看，我无法想象wchar_t*值不是有效的char*值的实现，所以您的代码在所有平台上都应该是可以的。只是不符合标准。|2407610|entityMap^0|2|7|A|4|Y|V|0|D|Q|0|0|0|0|0|E|8|S|5|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|11|8|@]|D|@]|E|$]]|$1|I|3|J|5|K|7|12|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|13|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|14|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@]|E|$]]|$1|P|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|Q|$]]

Since <code>wchar_t</code> and <code>char</code> are both built-in types, the correct deallocation function (<code>void operator delete(void* ptr)</code>) would be called, and there is no destructor to call.

However the C++ 03 standard says the result of <code>reinterpret_cast&lt;T1*&gt;(T2*)</code> is undefined (section 5.2.10.7): 

<blockquote>
 A pointer to an object can be explicitly converted to a pointer to an object of different type. Except that
 converting an rvalue of type “pointer to T1” to the type “pointer to T2” (where T1 and T2 are object types
 and where the alignment requirements of T2 are no stricter than those of T1) and back to its original type
 yields the original pointer value, the result of such a pointer conversion is unspecified. 
</blockquote>

From a practical POV I can't imagine an implementation where a <code>wchar_t*</code> value is not a valid <code>char*</code> value, so your code should be OK on all the platforms. Just not standard-compliant...

In my code I have effectively the following:

<pre><code>wchar_t* buffer = new wchar_t[size];
// bonus irrelevant code here
delete[] reinterpret_cast&lt;char*&gt;( buffer );
</code></pre>

Types in question are all built-in and so they have trivial destructors. In VC++ the code above works allright - <code>new[]</code> just allocates memory, then <code>delete[]</code> just frees it.

Is it acceptable in C++? Is it undefined behaviour?

Can I new[], then cast the pointer, then delete[] safely with built-in types in C++?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

在我的代码中，我有效地实现了以下内容：wchar_t* buffer = new wchar_t[size];// bonus irrelevant code heredelete[] reinterpret_cast<char*>( buffer );有问题的类型都是内置的，所以它们有简单的析构函数。在VC++中，上...

问是否可以使用C++中的内置类型安全地执行new[]，然后强制转换指针，然后执行delete[]？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问是否可以使用C++中的内置类型安全地执行new[]，然后强制转换指针，然后执行delete[]？EN