blocks|key|956417|text|正确的选择可能是使用为您完成此工作的容器，如std::vector。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|956418|new和delete无法调整大小，因为它们分配的内存恰好足以容纳给定类型的对象。给定类型的大小永远不会改变。有new[]和delete[]，但几乎没有理由使用它们。|956419|不管怎样，realloc在C中所做的可能只是一个malloc，memcpy和free，尽管如果有足够的连续空闲内存可用，内存管理器可以做一些聪明的事情。|956420|entityMap^0|M|B|0|0|3|4|6|1J|5|1P|8|0|5|7|O|6|V|6|12|4|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]|$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]|$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|K|$]]

The right option is probably to use a container that does the work for you, like <code>std::vector</code>.

<code>new</code> and <code>delete</code> cannot resize, because they allocate just enough memory to hold an object of the given type. The size of a given type will never change. There are <code>new[]</code> and <code>delete[]</code> but there's hardly ever a reason to use them.

What <code>realloc</code> does in C is likely to be just a <code>malloc</code>, <code>memcpy</code> and <code>free</code>, anyway, although memory managers are allowed to do something clever if there is enough contiguous free memory available.

blocks|key|956473|text|使用::std::vector！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|956474|Type*+t+=+(Type*)malloc(sizeof(Type)*n)+
memset(t,+0,+sizeof(Type)*m)|code-block|syntax|javascript|956475|变成了|956476|::std::vector<Type>+t(n,+0);|956477|然后|956478|t+=+(Type*)realloc(t,+sizeof(Type)+*+n2);|956479|956480|t.resize(n2);|956481|如果要将指针传递到函数中，而不是|956482|Foo(t)|956483|使用|956484|Foo(&t[0])|956485|这是绝对正确C%2B%2B代码，因为向量是一个智能的C数组。|956486|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|15|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|17|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|18|8|@]|9|@]|A|$E|F]]|$1|O|3|H|5|6|7|19|8|@]|9|@]|A|$]]|$1|P|3|Q|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|R|3|S|5|6|7|1B|8|@]|9|@]|A|$]]|$1|T|3|U|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|V|3|W|5|6|7|1D|8|@]|9|@]|A|$]]|$1|X|3|Y|5|D|7|1E|8|@]|9|@]|A|$E|F]]|$1|Z|3|10|5|6|7|1F|8|@]|9|@]|A|$]]|$1|11|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|12|$]]

Use ::std::vector!

<pre><code>Type* t = (Type*)malloc(sizeof(Type)*n) 
memset(t, 0, sizeof(Type)*m)
</code></pre>

becomes

<pre><code>::std::vector&lt;Type&gt; t(n, 0);
</code></pre>

Then

<pre><code>t = (Type*)realloc(t, sizeof(Type) * n2);
</code></pre>

becomes

<pre><code>t.resize(n2);
</code></pre>

If you want to pass pointer into function, instead of 

<pre><code>Foo(t)
</code></pre>

use

<pre><code>Foo(&amp;t[0])
</code></pre>

It is absolutely correct C++ code, because vector is a smart C-array.

blocks|key|956537|text|在C%2B%2B中调整大小很笨拙，因为可能需要调用构造函数和析构函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|956538|我不认为在C%2B%2B中不能有一个resize[]运算符来处理new[]和delete[]，这是一个根本的原因，它做了类似的事情：|offset|length|style|CODE|956539|newbuf+=+new+Type[newsize];
std::copy_n(oldbuf,+std::min(oldsize,+newsize),+newbuf);
delete[]+oldbuf;
return+newbuf;|code-block|syntax|javascript|956540|显然，oldsize将从一个秘密位置检索，与delete[]中的情况相同，并且Type将来自操作数的类型。在类型不可复制的情况下，resize[]将失败-这是正确的，因为这样的对象根本不能被重新定位。最后，上面的代码在赋值对象之前默认构造对象，这并不是您想要的实际行为。|956541|有一个可能的优化，在newsize+<=+oldsize中，调用对象的析构函数“超过”新安装的数组的末尾，而不做任何其他事情。标准必须定义这种优化是必需的(就像你使用resize()时一样)，允许但未指定，允许但依赖于实现，还是禁止。|956542|然后，您应该问自己的问题是：“鉴于vector也这样做，并且专门设计用于提供一个可调整大小的容器(连续内存--该要求在C%2B%2B98中省略，但在C%2B%2B03中得到了解决)，提供此功能是否真的有用?它比具有C%2B%2B方式的数组更适合？”|956543|我认为答案被广泛认为是“不”。如果你想用C语言做可调整大小的缓冲区，可以使用C%2B%2B中提供的malloc+/+free+/+realloc。如果你想用C%2B%2B的方式做可调整大小的缓冲区，使用一个向量(或者deque，如果你实际上不需要连续的存储)。不要试图通过将new[]用于原始缓冲区来混合这两者，除非您正在实现一个类似向量的容器。|956544|entityMap^0|0|E|8|S|5|Y|8|0|0|3|7|M|8|13|4|1T|8|0|A|I|2B|8|0|H|6|0|19|N|2S|5|3L|5|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@$D|Y|E|Z|F|G]|$D|10|E|11|F|G]|$D|12|E|13|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|14|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|15|8|@$D|16|E|17|F|G]|$D|18|E|19|F|G]|$D|1A|E|1B|F|G]|$D|1C|E|1D|F|G]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1E|8|@$D|1F|E|1G|F|G]|$D|1H|E|1I|F|G]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1J|8|@$D|1K|E|1L|F|G]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1M|8|@$D|1N|E|1O|F|G]|$D|1P|E|1Q|F|G]|$D|1R|E|1S|F|G]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1T|8|@]|9|@]|A|$]]]|V|$]]

Resizing in C++ is awkward because of the potential need to call constructors and destructors.

I don't think there's a fundamental reason why in C++ you couldn't have a <code>resize[]</code> operator to go with <code>new[]</code> and <code>delete[]</code>, that did something similar to this:

<pre><code>newbuf = new Type[newsize];
std::copy_n(oldbuf, std::min(oldsize, newsize), newbuf);
delete[] oldbuf;
return newbuf;
</code></pre>

Obviously <code>oldsize</code> would be retrieved from a secret location, same is it is in <code>delete[]</code>, and <code>Type</code> would come from the type of the operand. <code>resize[]</code> would fail where the Type is not copyable - which is correct, since such objects simply cannot be relocated. Finally, the above code default-constructs the objects before assigning them, which you would not want as the actual behaviour.

There's a possible optimisation where <code>newsize &lt;= oldsize</code>, to call destructors for the objects "past the end" of the newly-ensmallened array and do nothing else. The standard would have to define whether this optimisation is required (as when you <code>resize()</code> a vector), permitted but unspecified, permitted but implementation-dependent, or forbidden.

The question you should then ask yourself is, "is it actually useful to provide this, given that <code>vector</code> also does it, and is designed specifically to provide a resize-able container (of contiguous memory--that requirement omitted in C++98 but fixed in C++03) that's a better fit than arrays with the C++ ways of doing things?"

I think the answer is widely thought to be "no". If you want to do resizeable buffers the C way, use <code>malloc / free / realloc</code>, which are available in C++. If you want to do resizeable buffers the C++ way, use a vector (or <code>deque</code>, if you don't actually need contiguous storage). Don't try to mix the two by using <code>new[]</code> for raw buffers, unless you're implementing a vector-like container.

blocks|key|1170887|text|下面是一个std::move的例子，使用realloc实现一个简单的向量(*每次我们达到限制时2次)。如果有比我下面的副本更好的方法，请让我知道。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1170888|编译为：|1170889|++g%2B%2B+-std=c%2B%2B2a+-O2+-Wall+-pedantic+foo.cpp|code-block|syntax|javascript|1170890|代码：|1170891|#include+<iostream>
#include+<algorithm>

template<class+T>+class+MyVector+{
private:
++++T+*data;
++++size_t+maxlen;
++++size_t+currlen;
public:
++++MyVector<T>+()+:+data+(nullptr),+maxlen(0),+currlen(0)+{+}
++++MyVector<T>+(int+maxlen)+:+data+(new+T+[maxlen]),+maxlen(maxlen),+currlen(0)+{+}

++++MyVector<T>+(const+MyVector&+o)+{
++++++++std::cout+<<+"copy+ctor+called"+<<+std::endl;
++++++++data+=+new+T+[o.maxlen];
++++++++maxlen+=+o.maxlen;
++++++++currlen+=+o.currlen;
++++++++std::copy(o.data,+o.data+%2B+o.maxlen,+data);
++++}

++++MyVector<T>+(const+MyVector<T>&&+o)+{
++++++++std::cout+<<+"move+ctor+called"+<<+std::endl;
++++++++data+=+o.data;
++++++++maxlen+=+o.maxlen;
++++++++currlen+=+o.currlen;
++++}

++++void+push_back+(const+T&+i)+{
++++++++if+(currlen+>=+maxlen)+{
++++++++++++maxlen+*=+2;
++++++++++++auto+newdata+=+new+T+[maxlen];
++++++++++++std::copy(data,+data+%2B+currlen,+newdata);
++++++++++++if+(data)+{
++++++++++++++++delete[]+data;
++++++++++++}
++++++++++++data+=+newdata;
++++++++}
++++++++data[currlen%2B%2B]+=+i;
++++}

++++friend+std::ostream&+operator<<(std::ostream+&os,+const+MyVector<T>&+o)+{
++++++++auto+s+=+o.data;
++++++++auto+e+=+o.data+%2B+o.currlen;;
++++++++while+(s+<+e)+{
++++++++++++os+<<+"["+<<+*s+<<+"]";
++++++++++++s%2B%2B;
++++++++}
++++++++return+os;
++++}
};

int+main()+{
++++auto+c+=+new+MyVector<int>(1);
++++c->push_back(10);
++++c->push_back(11);
}|1170892|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|$]]

Here's a std::move example implementing a simple vector with a realloc (*2 each time we hit the limit). If there's a way to do better than the copy I have below, pls let me know.

Compile as:

<pre><code> g++ -std=c++2a -O2 -Wall -pedantic foo.cpp
</code></pre>

Code:

<pre><code>#include &lt;iostream&gt;
#include &lt;algorithm&gt;

template&lt;class T&gt; class MyVector {
private:
 T *data;
 size_t maxlen;
 size_t currlen;
public:
 MyVector&lt;T&gt; () : data (nullptr), maxlen(0), currlen(0) { }
 MyVector&lt;T&gt; (int maxlen) : data (new T [maxlen]), maxlen(maxlen), currlen(0) { }

 MyVector&lt;T&gt; (const MyVector&amp; o) {
 std::cout &lt;&lt; "copy ctor called" &lt;&lt; std::endl;
 data = new T [o.maxlen];
 maxlen = o.maxlen;
 currlen = o.currlen;
 std::copy(o.data, o.data + o.maxlen, data);
 }

 MyVector&lt;T&gt; (const MyVector&lt;T&gt;&amp;&amp; o) {
 std::cout &lt;&lt; "move ctor called" &lt;&lt; std::endl;
 data = o.data;
 maxlen = o.maxlen;
 currlen = o.currlen;
 }

 void push_back (const T&amp; i) {
 if (currlen &gt;= maxlen) {
 maxlen *= 2;
 auto newdata = new T [maxlen];
 std::copy(data, data + currlen, newdata);
 if (data) {
 delete[] data;
 }
 data = newdata;
 }
 data[currlen++] = i;
 }

 friend std::ostream&amp; operator&lt;&lt;(std::ostream &amp;os, const MyVector&lt;T&gt;&amp; o) {
 auto s = o.data;
 auto e = o.data + o.currlen;;
 while (s &lt; e) {
 os &lt;&lt; "[" &lt;&lt; *s &lt;&lt; "]";
 s++;
 }
 return os;
 }
};

int main() {
 auto c = new MyVector&lt;int&gt;(1);
 c-&gt;push_back(10);
 c-&gt;push_back(11);
}
</code></pre>

How can I <code>realloc</code> in C++? It seems to be missing from the language - there is <code>new</code> and <code>delete</code> but not <code>resize</code>!

I need it because as my program reads more data, I need to reallocate the buffer to hold it. I don't think <code>delete</code>ing the old pointer and <code>new</code>ing a new, bigger one, is the right option.

How do you 'realloc' in C++?

内存管理

容器

如何在C++中使用realloc？它似乎在语言中缺失了--有new和delete，但没有resize！我需要它，因为当我的程序读取更多的数据时，我需要重新分配缓冲区来容纳它。我不认为在旧指针上delete而在一个新的、更大的指针上new是正确的选择。

问你如何在C++中“重新定位”？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问你如何在C++中“重新定位”？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问你如何在C++中“重新定位”？
EN