blocks|key|1010666|text|One+example在Stroustrup的常见问题解答中。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1010667|entityMap|0|LINK|mutability|MUTABLE|url|http://www.stroustrup.com/bs_faq2.html#placement-delete^0|0|B|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

<a href="http://www.stroustrup.com/bs_faq2.html#placement-delete" rel="nofollow noreferrer">One example</a> is at Stroustrup's FAQ.

blocks|key|1010685|text|从技术上讲，放置operator+new是任何接受除所需内存大小之外的额外参数的operator+new。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1010686|因此，new(std::nothrow)+X使用放置operator+new，new(__FILE__,+__LINE__)+X也是如此。|1010687|覆盖operator+new(size_t,+void*)的唯一原因可能是添加跟踪信息，但我认为对此的需求将相当低。|1010688|entityMap^0|8|C|14|C|0|3|J|Q|C|13|P|0|2|R|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$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]]|D|@]|E|$]]|$1|H|3|I|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|K|$]]

Technically, a placement <code>operator new</code> is any <code>operator new</code> that takes additional arguments besides the size of the memory needed.

So, <code>new(std::nothrow) X</code> uses a placement <code>operator new</code> and so does <code>new(__FILE__, __LINE__) X</code>.

The only reason for overriding the <code>operator new(size_t, void*)</code> could be to add tracing information, but I think the need for that will be pretty low.

blocks|key|2983066|text|我的主要用途是创建一个大型对象数组。它的性能要好得多，并且在整个块中分配内存的开销更小，即使用Win32中的VirtualAlloc+(当编程窗口时)。然后，您只需将该块中的ptr传递给每个对象位置new，例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2983067|char+*cp+=+new+char[totalSize];

for(i+=+0;+i+<+count;+i%2B%2B,+cp+%2B=+ObjSize)++++++++
{++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++myClass+*obj+=+new(cp)+myClass;+++++++++++++
}|code-block|syntax|javascript|2983068|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|$]]

My primary usage is to create a large array of objects. Its performing much better and has less overhead to allocate the memory in a whole block, i.e. using VirtualAlloc from Win32 (when programming windows). Then you just pass a ptr within that block to each objects placement new such as:

<pre><code>char *cp = new char[totalSize];

for(i = 0; i &lt; count; i++, cp += ObjSize) 
{ 
 myClass *obj = new(cp) myClass; 
}
</code></pre>

blocks|key|1757002|text|最明显的替代方法是复制此实现。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1757003|另一个明智的方法是添加一些检查(例如，验证请求区域中没有“绑定标记”)。|1757004|然而，我认为，由于名称查找的机制(或者不覆盖它来阻止它的使用，这也是很好的，但这是一个有意识的决定)，一旦您覆盖了其他(对于给定的类)，重点就不只是必须覆盖它了。|1757005|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|$]]

The most obvious override would be to copy this implementation.

Another sensible one would be to add some checks (for example, verifying that there is no "bound-marker" within the request zone).

I think however that the point is more than you HAVE to override it, as soon as you override the others (for a given class), because of the mechanics of name look up (or not overriding it to prevent its use, that's fine too, but it's a conscious decision).

blocks|key|4392636|text|我见过一个例子，其中双参数new+[]被重写以返回预先填充了作为附加参数传递的char的内存块。我不记得原始代码使用了什么(可能是memset())，但它的功能是这样的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4392637|#include+<iostream>
#include+<algorithm>
#include+<new>
void*+operator+new+[](size_t+n,+char+c)
{
++++++++char*+p+=+new+char[n];
++++++++std::fill(p,+p%2Bn,+c);
++++++++return+p;
}
int+main()
{
++++++++char*+p+=+new('a')+char[10];
++++++++std::cout+<<+p[0]+<<+p[1]+<<+".."+<<+p[9]+<<+'\n';
}|code-block|syntax|javascript|4392638|虽然我猜这不会被称为“放置”新的，因为它不执行放置。如果它被模板化，这样它可以构建任何类型的数组，并填充作为第二个参数传递的对象的副本，那么它可能会很有用……但话说回来，我们还是有容器的。|4392639|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I've seen an example where two-argument new [] was overwritten to return memory blocks pre-filled with the char passed as the additional argument. I don't remember what the original code used (probably memset()), but it was functionally something like this:

<pre><code>#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;new&gt;
void* operator new [](size_t n, char c)
{
 char* p = new char[n];
 std::fill(p, p+n, c);
 return p;
}
int main()
{
 char* p = new('a') char[10];
 std::cout &lt;&lt; p[0] &lt;&lt; p[1] &lt;&lt; ".." &lt;&lt; p[9] &lt;&lt; '\n';
}
</code></pre>

although I guess this wouldn't be called "placement" new because it does not perform placement. It could probably be useful if templated so that it can build arrays of any type, filled with a copy of the object passed as its second argument... but then, we have containers for that anyway.

blocks|key|2983200|text|正确的答案是，你不能替换运算符放置新的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2983201|2983202|§18.4.​1.3放置表单|blockquote|2983203|2983204|这些函数是保留的，C%2B%2B程序不能定义取代标准C%2B%2B库中的版本的函数。|2983205|2983206|基本原理:分配和释放操作符的唯一目的是分配和释放内存，所以当给定内存时，不应该再做任何事情。(该标准特别指出，这些函数“故意不执行任何其他操作”。)|2983207|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|O|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|P|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|R|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|S|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|T|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|M|$]]

The correct answer is you cannot replace operator placement new.

<blockquote>
 §18.4.​1.3 Placement forms 
 These functions are reserved, a C++ program may not define functions that displace the versions in the Standard C++ library.
</blockquote>

The rationale: The only purpose of the allocation and deallocation operators is to allocate and deallocate memory, so when given memory nothing more should be done. (The standard specifically notes that these functions "Intentionally perform no other action.")

blocks|key|4392708|text|我不是很确定这个问题，但是下面的代码覆盖了类级别的新位置：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4392709|struct+Bar+{
void*+operator+new(size_t+/*+ignored+*/,+void*+where)+throw()+{+return+where;+}
};

int+main()+{
++char+mem[1];
++Bar*+bar+=+new(mem)+Bar;
}|code-block|syntax|javascript|4392710|我相信这是合法的C%2B%2B+(并且使用gcc+4.4.6编译和运行得很好)。|4392711|您可以随意更改该操作符的实现(包括删除throw()子句，这意味着编译器在调用构造函数之前不再检查where指针是否为null+)。不过，要小心行事。|offset|length|style|CODE|4392712|§18.4.​1.3很有趣。我相信这只适用于全局运算符的新函数，而不适用于类特定的函数。|4392713|entityMap^0|0|0|0|J|7|1D|5|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|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|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

I'm not exactly sure of the question, but the following overrides placement new at the class level:

<pre><code>struct Bar {
void* operator new(size_t /* ignored */, void* where) throw() { return where; }
};

int main() {
 char mem[1];
 Bar* bar = new(mem) Bar;
}
</code></pre>

I believe this is legal C++ (and compiles and runs fine with gcc 4.4.6). 

You are free to change the implementation of this operator as you see fit (including removing the <code>throw()</code> clause, which will mean the compiler no longer checks the <code>where</code> pointer for null before calling the constructor). Tread carefully though.

§18.4.​1.3 is interesting. I believe this just applies to the global operator new function, not class specific ones.

blocks|key|1010808|text|放置新重载的最重要的额外功能是检查地址对齐。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1010809|例如，假设某些类需要16字节对齐。开发人员重载了new、new[]、delete和delete[]+-只是为了确保一切都正确对齐。|1010810|当他尝试将他的类与库一起使用时，一切都运行得很好，该库使用了新的位置...库不知道类和地址是否需要对齐/需要什么对齐，它试图将对象“放置”到可能不对齐的地方-大爆炸。|1010811|这种情况的最简单示例-尝试使用std::vector，其中T需要非标准对齐。|1010812|放置新的重载允许检测指针是否未对齐-可能会节省几个小时的调试时间。|1010813|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

The most important extra-functionality for placement new overload would be to check address alignment.

For example, lets assume some class requires 16-bytes alignment. Developer overloads new, new[], delete and delete[] - just to be sure everything is aligned properly.

Everything works fine to the moment when he tries to use his class with library which uses placement new... Library has no idea if/what alignment is required for the class and address it tries to "place" the object to might not be aligned - big boom.

The simplest example of such situation - try using std::vector&lt;T&gt; where T requires non-standard alignment.

Overload for placement new allows to detect if pointer is not aligned - might save hours of debugging.

blocks|key|1753997|text|为预保留区域定义自己的内存管理是一个很好的用途。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1753998|对同一物理数据有不同的视图(不需要移动数据)是其他有趣的用途。它还允许您将结构化文件读取为缓冲区上的字符，然后通过在缓冲区上定义该类的对象来叠加它们的逻辑结构。将其与文件的内存映射相结合，可以大大提高性能。内存映射硬件...所以，成千上万的应用程序！|1753999|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

To define your own memory management for a prereserved area is one nice use.

To have different views on the same physical data (no need to move the data) is other interseting use.
It also allows you reading a structured file as chars on a buffer and then, the superimposition of the their logical structure by defining an object of that the class over the buffer. 
The combination of this thing with the memory mapping of files, can provide big improvements in performance.
The memory mapped hardware...
So, thousand applications!

C++ allows overloading <code>operator new</code> - both global and per-class - usual <code>operator new</code>, <code>operator new[]</code> used with <code>new[]</code> statement and placement <code>operator new</code> separately.

The former two of those three are usually overloaded for using customized allocators and adding tracing. But placement <code>operator new</code> seems pretty straightforward - it actually does nothing inside. For example, in Visual C++ the default implementation just returns the address passed into the call:

<pre><code>//from new.h
inline void* operator new( size_t, void* where )
{
 return where;
}
</code></pre>

What else could it do? Why and how could I sensibly overload placement <code>operator new</code>?

How could I sensibly overload placement operator new?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

C++允许重载operator new -全局的和每个类的-通常的operator new，operator new[]分别与new[]语句和放置operator new一起使用。这三种方法中的前两种通常会因为使用自定义分配器和添加跟踪而超载。但是placement operator new看起来非常简单--它实际上不...

问我怎样才能明智地重载放置操作符new？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我怎样才能明智地重载放置操作符new？EN