blocks|key|1617533|text|这个STL成员的原因是让开发人员更好地控制内存。我的意思是，例如，新的操作符本身并不仅仅是一个操作。最基本的是，它执行内存的保留，然后用对象填充这个空间。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1617534|虽然我无法在头脑中想出一个具体的、真实的案例场景，但是您应该使用std::allocator，或者，当对给定对象的破坏可能会影响内存中的其他对象时。|style|CODE|1617535|比如说，为了论证，您创建了某种向量，每个元素都是双链接到内存中的其他对象，在删除所述向量时，您希望链接的对象删除对它的引用。|1617536|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Standard_Template_Library^0|2|3|0|0|W|E|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]]|C|$]]|$1|D|3|E|5|6|7|V|8|@$A|W|B|X|F|G]]|9|@]|C|$]]|$1|H|3|I|5|6|7|Y|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|Z|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]]]

The reason for this <a href="http://en.wikipedia.org/wiki/Standard_Template_Library" rel="nofollow">STL</a> member is to give the developer more control over memory. What I mean by this is, for instance, the new operator is not really just one operation per se. At its most basic, it performs a reservation of memory AND then fills that space with the object.

Although I cannot on top of my head come up with a specific, real-world case scenario, you should use <code>std::allocator</code> and such when, perhaps, the destruction of a given object might impact other objects in memory.

Let's say, for the sake of argument, you created some kind of vector which each element is double-linked to some other object in memory and you want, at the time of deletion of said vector, the objects linked to remove the reference back to it.

blocks|key|415401|text|创建std::allocator是为了让开发人员更好地控制内存的分配。在许多嵌入式系统中，内存受到限制，类型也不同。可能不会有什么大数目。此外，内存分配也希望最小化，以避免碎片问题。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|415402|分配器还允许从不同的内存池中分配。因此，例如，从一个小块内存池中分配小块将更有效。|415403|entityMap^0|2|E|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

The <code>std::allocator</code> was created to allow developers more control of how memory is allocated. In many embedded systems, memory is constrained and in different types. There may not be a huge amount. Also, memory allocation wants to be minimized to avoid fragmentation issues.

The allocator also allows for allocation from different memory pools. So for example, allocating small sized blocks would be more efficient from a small block memory pool.

blocks|key|1617607|text|分配器是STL中一个非常重要的概念。每个容器都能够接受一个分配器作为参数。然后将使用此分配程序执行分配，而不是使用标准分配程序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1617608|这是有用的，例如，在池中分配相同大小的对象，以提高性能，或者，如果您的对象需要在内存中有特殊区域，则可能需要这样做。|1617609|分配和构造的步骤是分开的，因为对于向量(std::vector::reserve)来说，重要的是能够为将来的使用分配内存，而不是(目前)在其中创建对象。|offset|length|style|CODE|1617610|作为一个示例，您可以将一个分配器编写为一个类，其中包含一个固定大小的数组，并使用该数组为某个标准容器提供内存。然后，您可以在堆栈上拥有该类的一个实例，从而完全避免为程序的某些部分分配堆。|1617611|在这里看到更多的例子在这篇文章中。|1617612|..。什么时候该用..。|blockquote|1617613|当您有特定需求时，最重要的是编写自己的泛型容器时。|1617614|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/cpp/container/vector/reserve|1|https://codereview.stackexchange.com/questions/31528/a-working-stack-allocator|2|https://stackoverflow.com/questions/826569/compelling-examples-of-custom-c-allocators^0|0|0|K|K|K|K|0|0|4|2|1|0|0|H|2|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|16|8|@$F|17|G|18|H|I]]|9|@$F|19|G|1A|1|1B]]|A|$]]|$1|J|3|K|5|6|7|1C|8|@]|9|@$F|1D|G|1E|1|1F]]|A|$]]|$1|L|3|M|5|6|7|1G|8|@]|9|@$F|1H|G|1I|1|1J]]|A|$]]|$1|N|3|O|5|P|7|1K|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1L|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]|10|$5|V|W|X|A|$Y|11]]|12|$5|V|W|X|A|$Y|13]]]]

Allocators are a very important concept in the STL. Every container is capable to take an allocator as argument. Then allocations will be performed using this allocator, and not the standard one.

This is useful e.g. for allocating objects of the same size in a pool, to improve performance, or might be necessary if there's a special area of memory where your objects need to live.

The steps of allocating and constructing are separate because e.g. for vector (<a href="http://en.cppreference.com/w/cpp/container/vector/reserve" rel="noreferrer"><code>std::vector::reserve</code></a>) it's important to be able to allocate memory for future use, but not (yet) create objects therein.

As an <a href="https://codereview.stackexchange.com/questions/31528/a-working-stack-allocator">example</a> you could write an allocator as a class, containing an fixed size array, and use that array to provide memory for some standard container. Then you can have an instance of that class on the stack and thus completely avoid heap allocations for some part of your programm.

<a href="https://stackoverflow.com/questions/826569/compelling-examples-of-custom-c-allocators">See more examples here in this SO post.</a>

<blockquote>
 [...] when should it be used [...]
</blockquote>

When you have specific needs, and most important when writing own generic containers.

blocks|key|414509|text|你的直觉是对的。在90%25的情况下，使用new。但是，在类似于地图数据结构的结构中要注意。它的默认模板参数之一是class+Alloc+=+allocator<pair<const+Key,T>，它定义了类如何创建新的事物实例并管理现有实例。这样，理论上可以创建自己的分配器，然后将其用于现有的数据结构。因为new和delete是函数而不是类，所以有必要让std::allocator来表示它们并使它们成为有效的模板参数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|414510|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cplusplus.com/reference/map/map/?kw=map^0|J|3|1J|15|49|3|4D|6|4X|E|U|2|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@$9|Y|A|Z|1|10]]|E|$]]|$1|F|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

Your instinct is right. In 90% of cases, use <code>new</code>. However, notice in structures like, say, the <a href="http://www.cplusplus.com/reference/map/map/?kw=map" rel="noreferrer">map</a> data structure. One of its default template arguments is <code>class Alloc = allocator&lt;pair&lt;const Key,T&gt;</code>, which defines how the class creates new instances of things and manages existing instances. In this way, you could theoretically create your own allocator and then use it for existing data structures. Since <code>new</code> and <code>delete</code> are functions and not classes, it is necessary to have the <code>std::allocator</code> to represent them and make them valid template arguments.

blocks|key|1617649|text|std::allocator是标准库容器的默认内存分配器，您可以替换自己的分配器。这允许您控制标准容器如何分配内存。但我不认为您的问题是专门关于std::allocator的，而是分配内存的策略，然后在该内存中构造对象，而不是使用new+T[N]。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1617650|其原因是new+T[N]不允许您控制调用什么构造函数。它迫使你同时构造你的所有对象。这对于例如std::vector来说是很糟糕的，在这里您只想偶尔分配。|1617651|使用原始内存分配器，您可以分配一定数量的内存，这决定了您的容量。然后，当用户将项添加到向量(使用他们选择的构造函数)时，您可以在这个内存中构造合适的对象。|1617652|然后，当内存耗尽时，分配的内容会更多，通常是原来的两倍。如果std::vector使用new+T[N]，那么每当您想要添加或删除元素时，它都必须重新分配，这对性能影响很大。您还将被迫对所有对象使用默认构造函数，这对std::vector可以容纳的对象类型设置了不必要的限制。|1617653|entityMap^0|0|E|20|E|37|8|0|4|8|1B|B|0|0|U|B|17|8|2Z|B|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|Z|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|L|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|M|$]]

<code>std::allocator</code> is the default memory allocator for the standard library containers, and you can substitute your own allocators. This allows you to control how the standard containers allocate memory. But I don't think that your question is about <code>std::allocator</code> specifically, but rather the strategy of allocating memory, then constucting objects in that memory, rather than using <code>new T[N]</code>, for example.

And the reason for that is that <code>new T[N]</code> doesn't allow you control over what constructors are called. And it forces you to construct all your objects at the same time. This is terrible for the purposes of, for example, <code>std::vector</code> where you only want to allocate occasionally.

With a raw memory allocator, you can allocate a certain amount of memory, which determines your capacity. Then, as the user adds items to the vector (using the constructor of their choice), you can construct objects in place in this memory.

Then when you run out of memory, you allocate more, typically twice as much. If <code>std::vector</code> used <code>new T[N]</code>, it would have to reallocate every time you wanted to add or remove an element, which would be terrible for performance. You would also be forced to use the default constructor for all the objects, which puts an unnecessary restriction on the types of objects <code>std::vector</code> can hold.

blocks|key|1617688|text|在我看来，使用它比使用新的和删除的更复杂。|type|blockquote|depth|inlineStyleRanges|entityRanges|data|1617689|是的，但它并不意味着要取代new和delete，它有着不同的用途。|unstyled|offset|length|style|CODE|1617690|使用分配器，我们必须显式地分配堆内存，构造它，销毁它，然后最后释放内存。
那么它为什么被创造出来呢？|1617691|因为有时您希望将分配和构造分离为两个步骤(类似于将销毁和退分配分离为两个步骤)。如果您不想这样做，不要使用分配器，而是使用new。|1617692|在哪些情况下可以使用它，什么时候应该使用它而不是新的和删除的？|1617693|显然，当您需要分配程序的行为时，而不是new和delete的行为！典型的情况是在实现容器时。|1617694|考虑以下代码：|1617695|std::vector<X>+v;
v.reserve(4);++++++++//+(1)
v.push_back(+X{}+);++//+(2)
v.push_back(+X{}+);++//+(3)
v.clear();+++++++++++//+(4)|code-block|syntax|javascript|1617696|这里的第(1)行必须为四个对象分配足够的内存，但还不能构造它们。然后，行(2)和(3)必须将对象构造到分配的内存中。然后行(4)必须销毁这些对象，但不能释放内存。最后，在向量的析构函数中，可以释放所有内存。|1617697|因此向量不能仅仅使用new+X()或delete+&m_data[1]来创建和销毁对象，它必须与构造/销毁分开执行分配/去分配。容器的分配器模板参数定义了用于(De)分配内存和构造/析构对象的策略，允许定制容器对内存的使用。默认策略是std::allocator类型。|1617698|因此，当需要分配器时(例如在使用容器时)使用分配器，当您不想提供自定义分配器而只想要标准分配器时使用std::allocator。|1617699|您不使用分配器代替new和delete。|1617700|entityMap^0|0|D|3|H|6|0|0|1P|3|0|0|J|3|N|6|0|0|0|0|A|7|I|H|39|E|0|1E|E|0|9|3|D|6|0^^$0|@$1|2|3|4|5|6|7|17|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|18|8|@$E|19|F|1A|G|H]|$E|1B|F|1C|G|H]]|9|@]|A|$]]|$1|I|3|J|5|6|7|1D|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|1E|8|@$E|1F|F|1G|G|H]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1H|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|1I|8|@$E|1J|F|1K|G|H]|$E|1L|F|1M|G|H]]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1N|8|@]|9|@]|A|$]]|$1|S|3|T|5|U|7|1O|8|@]|9|@]|A|$V|W]]|$1|X|3|Y|5|D|7|1P|8|@]|9|@]|A|$]]|$1|Z|3|10|5|D|7|1Q|8|@$E|1R|F|1S|G|H]|$E|1T|F|1U|G|H]|$E|1V|F|1W|G|H]]|9|@]|A|$]]|$1|11|3|12|5|D|7|1X|8|@$E|1Y|F|1Z|G|H]]|9|@]|A|$]]|$1|13|3|14|5|D|7|20|8|@$E|21|F|22|G|H]|$E|23|F|24|G|H]]|9|@]|A|$]]|$1|15|3|-4|5|D|7|25|8|@]|9|@]|A|$]]]|16|$]]

<blockquote>
In my opinion, it is more complicated to use it instead of using new and delete.
</blockquote>
Yes, but it is not meant to replace <code>new</code> and <code>delete</code>, it serves a different purpose.
<blockquote>
With allocator we must explicitly allocate heap memory, construct it, destroy it, and then finally deallocate the memory.
So why was it created?
</blockquote>
Because sometimes you want to separate allocation and construction into two steps (and similarly to separate destruction and deallocation into two steps). If you don't want to do that, don't use an allocator, use <code>new</code> instead.
<blockquote>
In which cases can it be used and when should it be used instead of new and delete?
</blockquote>
When you need the behaviour of an allocator, not the behaviour of <code>new</code> and <code>delete</code>, obviously! The typical case is when implementing a container.
Consider the following code:
<pre><code>std::vector&lt;X&gt; v;
v.reserve(4); // (1)
v.push_back( X{} ); // (2)
v.push_back( X{} ); // (3)
v.clear(); // (4)
</code></pre>
Here line (1) must allocate enough memory for four objects, but not construct them yet. Then lines (2) and (3) must construct objects into the allocated memory. Then line (4) must destroy those objects, but not deallocate the memory. Finally, in the vector's destructor, all the memory can be deallocated.
So the vector cannot just use <code>new X()</code> or <code>delete &amp;m_data[1]</code> to create and destroy the objects, it must perform allocation/deallocation separately from construction/destruction. A container's allocator template argument defines the policy that should be used for (de)allocating memory and constructing/destructing objects, allowing the container's use of memory to be customised. The default policy is the <code>std::allocator</code> type.
So you use an allocator when an allocator is required (such as when using a container) and you use <code>std::allocator</code> when you don't want to provide a custom allocator and just want the standard one.
You don't use an allocator as a replacement for <code>new</code> and <code>delete</code>.

blocks|key|1617713|text|new和delete是在动态内存中创建对象并对其进行初始化的直接方法。然而，分配程序要多得多，因为它们提供了对上述阶段的完全控制。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1617714|使用分配器，我们必须显式地分配堆内存，构造它，销毁它，然后最后释放内存。|blockquote|1617715|实际上，分配器不应该用于“正常”代码，因为在这些代码中，new和delete同样适用。考虑像std::map这样的类，通常是作为树实现的:每当删除持有的对象时，是否需要释放整个叶子？分配器允许您销毁该对象，但保留内存，这样您就不必再需要它了。|1617716|此外，如果您知道更多优化的方法来控制某个类型的分配器，而这对于new和delete来说是不可能的，那么您可以将其专门化。|1617717|entityMap^0|0|3|4|6|0|0|S|3|W|6|1A|8|0|V|3|Z|6|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$]]|$1|I|3|J|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|K|3|L|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|N|$]]

<code>new</code> and <code>delete</code> are the direct way to create an object in dynamic memory and initialize it. Allocators are much more though, because they offer complete control over the aforementioned phases.

<blockquote>
 With allocator we must explicitly allocate heap memory, construct it,
 destroy it, and then finally deallocate the memory.
</blockquote>

Indeed allocators are not supposed to be used for "normal" code where <code>new</code> and <code>delete</code> would equally be fine. Consider a class like <code>std::map</code>, often implemented as a tree: do you need to deallocate the whole leaf whenever an object held is deleted? Allocators allow you do destruct that object, but keep the memory so that you don't have to require it again.

Further, you may specialize an allocator for a certain type if you know more optimized methods for its control which is not possible for <code>new</code> and <code>delete</code>.

blocks|key|414557|text|你很困惑。std::allocator调用/使用new和delete。它只是C%2B%2B内存层次结构中的另一个级别，用于满足C%2B%2B标准库的各种需求，特别是容器，但其他类型也是如此。C%2B%2B库容器使用分配器自动管理包含元素的内存。没有它，事情会更麻烦，因此更难以使用。此外，还可以使用分配器来执行不同的内存管理技术，如堆栈分配、线性分配、堆分配、池分配等。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|414558|C%2B%2B内存“层次结构”|414559|_________________
%7CApplications+++%7C
%7C_______________%7C
++++++%7C
______↓_______________________
%7CC%2B%2B+library+(std::allocator)%7C
%7C____________________________%7C
++++++%7C
______↓______________________________________________________________________________
%7CC%2B%2B+primitives+(new/delete,+new[]/delete[],+::operator+new()/::operator+delete())++%7C
%7C___________________________________________________________________________________%7C
++++++%7C
______↓______
%7Cmalloc/free%7C
%7C___________%7C
++++++%7C
______↓______________
%7COS+APIs,+syscalls++%7C
%7C___________________%7C|code-block|syntax|javascript|414560|这是正常的调用流程，但是应用程序可以直接调用malloc/free，新/delete，甚至OS。你看，这都是一种抽象。上述级别抽象了该级别的更难的性质，并将其封装在一个更易于使用的包中。|414561|entityMap^0|5|E|O|3|S|6|0|0|0|0^^$0|@$1|2|3|4|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|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|P|$]]

You are confused. <code>std::allocator</code> calls/uses <code>new</code> and <code>delete</code>. It is simply another level in the C++ memory hierarchy, used to serve the various needs of the C++ standard library, particularly the containers, but other types too. The C++ library containers use the allocator to automatically manage the memory of the contained elements. Without it, things would be more cumbersome and thus more difficult to use. Furthermore an allocator can be used to perform different techniques of memory management, eg stack allocation, linear allocation, heap allocation, pool allocation etc.

C++ memory "hierarchy"

<pre><code>_________________
|Applications |
|_______________|
 |
______↓_______________________
|C++ library (std::allocator)|
|____________________________|
 |
______↓______________________________________________________________________________
|C++ primitives (new/delete, new[]/delete[], ::operator new()/::operator delete()) |
|___________________________________________________________________________________|
 |
______↓______
|malloc/free|
|___________|
 |
______↓______________
|OS APIs, syscalls |
|___________________|
</code></pre>

This is the normal flow of calls, but an application can instead call malloc/free, or new/delete or even the OS APIs directly. You see it's ALL an abstraction. The level above abstracts the more difficult nature of the one and wraps it in an easier to use package.

I've just read about <code>std::allocator</code>. In my opinion, it is more complicated to use it instead of using <code>new</code> and <code>delete</code>. 

With <code>allocator</code> we must explicitly allocate heap memory, construct it, destroy it, and then finally deallocate the memory. So why was it created? 

In which cases can it be used and when should it be used instead of new and delete?

What's the advantage of using std::allocator instead of new in C++?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我刚读到关于std::allocator的文章。在我看来，使用它比使用new和delete要复杂得多。使用allocator，我们必须显式地分配堆内存，构造它，销毁它，然后最后释放内存。那么它为什么被创造出来呢？在哪些情况下可以使用它，什么时候应该使用它而不是新的和删除的？

问在C++中使用std::allocator而不是new的优点是什么？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++中使用std::allocator而不是new的优点是什么？EN