blocks|key|4080303|text|这是可能的，但没有预先编写的函数来做这件事。您必须深入研究编译器的alloca()实现，以找出它在做什么，然后编写您自己的freea()。由于每个编译器执行alloca()的方式不同，因此您必须为每个编译器重写freea()。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4080304|但我发现很难相信这是值得的。如果您需要显式地释放它，只需使用malloc/free+-这些函数通常都经过了大量优化。充分利用它们。|4080305|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|$]]

It is possible, but there is no pre-written function to do it. You'd have to delve into your compiler's implementation of alloca() to figure out what it is doing, then write your own freea(). Since every compiler does alloca() differently, you'd have to rewrite your freea() for each compiler.

But I find it hard to believe this would be worth the trouble. Just use malloc/free if you need to explicitly free it - those functions are usually heavily optimized. Take advantage of them.

blocks|key|3233854|text|来自http://www.gnu.org/software/libc/manual/html_mono/libc.html#Variable-Size-Automatic|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3233855|3233856|使用alloca分配一个块是一个显式的操作；您可以根据需要分配任意多的块，并在运行时计算大小。但是，当您退出从中调用alloca的函数时，所有块都会被释放，就像它们是在该函数中声明的自动变量一样。无法显式释放空间。|blockquote|style|CODE|BOLD|3233857|3233858|entityMap|0|LINK|mutability|MUTABLE|url|http://www.gnu.org/software/libc/manual/html_mono/libc.html#Variable-Size-Automatic^0|2|2B|0|0|0|2|6|2Q|9|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|D|3|-4|5|6|7|X|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|Y|8|@$A|Z|B|10|H|I]|$A|11|B|12|H|J]]|9|@]|C|$]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|C|$]]|$1|L|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|M|$N|$5|O|P|Q|C|$R|S]]]]

From <a href="http://www.gnu.org/software/libc/manual/html_mono/libc.html#Variable-Size-Automatic" rel="noreferrer">http://www.gnu.org/software/libc/manual/html_mono/libc.html#Variable-Size-Automatic</a>:

<blockquote>
 Allocating a block with <code>alloca</code> is an explicit action; you can allocate as many blocks as you wish, and compute the size at run time. But all the blocks are freed when you exit the function that alloca was called from, just as if they were automatic variables declared in that function. There is no way to free the space explicitly.
</blockquote>

blocks|key|3233819|text|你正在使用alloca()在堆栈上进行分配；如果之后发生了其他事情(而且你不能控制它，除非用汇编语言写所有的东西)，你不能只是缩小堆栈。所以，除非你离开函数的堆栈框架，否则这是不可能的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3233820|这也是为什么如果你使分配的缓冲区溢出，你会把事情搞得一团糟。你可以开始覆盖你的函数返回的代码的地址，导致它跳转到其他地方，所有可怕的东西。注意!|3233821|Malloc在堆上工作，这就是为什么它可以做更灵活的事情。|3233822|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|$]]

You are allocating on the stack with alloca(); If something else happened afterwards (and you can't control it without writing everything in assembly), you can't just shrink the stack back. So until you leave the stack frame of your function, this is impossible.

This is also why you can really mess things up if you overflow the allocated buffer. You can start overwriting addresses of code your function returns to, causing it to jump elsewhere, all kinds of horrid stuff. Be careful!

Malloc works on the heap, so that's why it is much more flexible in what it can do.

blocks|key|12386|text|通过使用C99，您可以使用Variable+Length+Array实现相同的功能。只需在新的作用域中声明VLA；当作用域退出时，它将自动释放。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|12387|例如：|12388|int+some_function(int+n)+{
++++//+n+has+the+desired+length+of+the+array
++++...
++++{+//+new+scope
++++++++int+arr[n];+//+instead+of+int+*arr+=+alloca(n*sizeof(int));
++++++++//+do+stuff+with+array
++++}
++++//+function+continues+with+arr+deallocated
++++...
}|code-block|syntax|javascript|12389|entityMap|0|LINK|mutability|MUTABLE|url|https://gcc.gnu.org/onlinedocs/gcc/Variable-Length.html^0|D|L|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|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

Using C99 you can achieve the same thing using a <a href="https://gcc.gnu.org/onlinedocs/gcc/Variable-Length.html" rel="nofollow">Variable Length Array</a>. Just declare the VLA in a new scope; it will automatically be freed when the scope exits.

For example:

<pre><code>int some_function(int n) {
 // n has the desired length of the array
 ...
 { // new scope
 int arr[n]; // instead of int *arr = alloca(n*sizeof(int));
 // do stuff with array
 }
 // function continues with arr deallocated
 ...
}
</code></pre>

blocks|key|4080337|text|这对于延续传递风格(CPS)很有用，而不是realloca。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4080338|你可以调用一个函数，在堆栈的顶部分配和操作一个字符串，然后将堆栈缩小到字符串的长度，然后调用下一个函数。|4080339|没有概念上的理由为什么不能有一个freea()，除了堆栈最上面的条目之外，它对于任何东西都是nop。|4080340|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|$]]

This would be useful for continuation passing style (CPS), rather a realloca.

You could call a function which alloca'd and manipulated a string on the top of the stack, before shrinking the stack back down to the length of the string and calling the next function.

There's no conceptual reason why there couldn't be an freea(), which would be a nop for anything but the topmost entry on the stack.

blocks|key|3233778|text|不是，因为它和局部变量一起在堆栈上被分配。如果需要显式释放的内存，请使用动态内存分配函数之一。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3233779|没有允许显式释放和的混合函数，至少在标准中不是这样。|offset|length|style|BOLD|3233780|entityMap^0|0|8|1|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

No, because it's allocated on the stack along with the local variables. If you want memory that you can explicitly free, use one of the dynamic memory allocation functions.

There's no hybrid that allows you to explicitly free AND have it automatically free on function exit as well, at least not in the standard.

blocks|key|3234045|text|是的，但这取决于alloca()的实现。alloca()的一个合理而简单的实现是，新分配的块通过调整堆栈指针放在堆栈的顶部。因此，要释放此内存，我们只需执行alloca负分配(但您需要研究alloca()的实际实现)，让我们以以下不可移植的代码为例进行验证：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3234046|#include+<stdio.h>
#include+<alloca.h>

int+main()
{
++unsigned+long+p0,+p1,+p2;
++p0=(unsigned+long)alloca(0);
++p1=(unsigned+long)alloca((size_t)+0x1000);
++p2=(unsigned+long)alloca((size_t)-0x1000);
++printf(+"p0=%25lX,+p1=%25lX,+p2=%25lX\n",+p0,+p1,+p2+);
++return+0;
}|code-block|syntax|javascript|3234047|在安装了clang2.9的旧x64机器上，示例输出为：|3234048|p0=7FFF2C75B89F,+p1=7FFF2C75A89F,+p2=7FFF2C75B89F|3234049|因此我们知道实现不会对参数-0x1000进行验证，否则无符号值将是一个非常大的整数。堆栈指针最初是0x...B89F；由于这个堆栈向上增长alloca(0x1000)，因此将堆栈指针up改为(0x...B89F+-+0x1000)+=+0x...A89F。在负分配(0xA89F+-+(-0x1000))之后，堆栈指针返回到0x...B89F。|3234050|但是，对于gcc+4.8.3，示例输出为：|3234051|p0=7FFFA3E27A90,+p1=7FFFA3E26A80,+p2=7FFFA3E27A70|3234052|在/usr/include/alloca.h中，我们发现：|3234053|#ifdef++__GNUC__
#+define+alloca(size)+++__builtin_alloca+(size)
#endif+/*+GCC.++*/|3234054|所以我们知道，gcc+4.8.3提供的内置分配函数做了类似的事情，只是它分配了额外的0x10字节作为安全余量。当进行负分配时，它仍然假设它向上增长，因此尝试保留0x10额外的字节(-+0x10)，因此p2=+0x...6A80+-+(-0x1000)+-+0x10+=+0x...7A70。所以，要格外小心。|3234055|entityMap^0|37|5|0|0|0|0|8|E|2J|2|2Y|1|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1F|8|@]|D|@]|E|$]]|$1|S|3|T|5|H|7|1G|8|@]|D|@]|E|$I|J]]|$1|U|3|V|5|6|7|1H|8|@]|D|@]|E|$]]|$1|W|3|X|5|H|7|1I|8|@]|D|@]|E|$I|J]]|$1|Y|3|Z|5|6|7|1J|8|@]|D|@]|E|$]]|$1|10|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]]|11|$]]

Yes, but it depends on the implementation of alloca(). A reasonable and simple implementation of alloca() is that the newly allocated block placed on top of stack by adjusting the stack pointer. Therefore to free this memory we only need to do a negative allocation (but you need to study the real implementation of alloca()), let's verify it by taking the following non-portable code for example:

<pre><code>#include &lt;stdio.h&gt;
#include &lt;alloca.h&gt;

int main()
{
 unsigned long p0, p1, p2;
 p0=(unsigned long)alloca(0);
 p1=(unsigned long)alloca((size_t) 0x1000);
 p2=(unsigned long)alloca((size_t)-0x1000);
 printf( "p0=%lX, p1=%lX, p2=%lX\n", p0, p1, p2 );
 return 0;
}
</code></pre>

On an old x64 machine with clang 2.9, a sample output is:

<pre><code>p0=7FFF2C75B89F, p1=7FFF2C75A89F, p2=7FFF2C75B89F
</code></pre>

So we know the implementation does not validate the argument -0x1000, otherwise the unsigned value will be a very large integer. Stack pointer was originally 0x...B89F; since this stack grows upward alloca(0x1000) therefore change the stack pointer up to (0x...B89F - 0x1000) = 0x...A89F. After the negative allocation (0xA89F - (-0x1000)) the stack pointer went back to 0x...B89F. 

However, with gcc 4.8.3, a sample output is:

<pre><code>p0=7FFFA3E27A90, p1=7FFFA3E26A80, p2=7FFFA3E27A70
</code></pre>

In /usr/include/alloca.h we found:

<pre><code>#ifdef __GNUC__
# define alloca(size) __builtin_alloca (size)
#endif /* GCC. */
</code></pre>

So we know that the builtin alloca function provided by gcc 4.8.3 did similar thing except it allocate extra 0x10 bytes as a safety margin. When doing negative allocation it still assumes it grows upward and therefore tried to reserve 0x10 extra bytes (- 0x10) so p2= 0x...6A80 - (-0x1000) - 0x10 = 0x...7A70. So, be extra careful.

blocks|key|870069|text|您不需要编写任何自定义的freea(...)类型的函数，也不需要使用VLA。在堆栈上分配的内存可以在C和C%2B%2B中轻松释放(C%2B%2B不支持VLA)。alloca(...)是在堆栈上分配的，对吧？这意味着当内存超出作用域时将被释放...所以就使用作用域吧！|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|870070|#include+<alloca.h>

int+main()
{
++++{
++++++++void*+ptr+=+alloca(1024);

++++++++//+do+your+stuff

++++}+//+memory+is+deallocated+here
++++
++++return+0;
}|code-block|syntax|javascript|870071|正如您从godbolt编译器中看到的那样，程序集(没有优化)做了正确的事情：https://godbolt.org/z/Gn5YMa|870072|entityMap|0|LINK|mutability|MUTABLE|url|https://godbolt.org/z/Gn5YMa^0|C|A|20|B|0|0|12|S|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@$9|11|A|12|1|13]]|E|$]]|$1|M|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

You don't need to write any custom <code>freea(...)</code> kind of function, nor use VLA.
Memory allocated on the stack can be easily freed in both C and C++ (C++ doesn't support VLAs).
The <code>alloca(...)</code> allocates on the stack, right? This means the memory is going to be deallocated when it goes out of scope... so just use scopes!
<pre class="lang-c prettyprint-override"><code>#include &lt;alloca.h&gt;

int main()
{
 {
 void* ptr = alloca(1024);

 // do your stuff

 } // memory is deallocated here
 
 return 0;
}
</code></pre>
As you can see from the godbolt online compiler, the assembly (with no optimization) does the right thing:
<a href="https://godbolt.org/z/Gn5YMa" rel="nofollow noreferrer">https://godbolt.org/z/Gn5YMa</a>

Is it possible to free memory allocated by C's alloca() explicitly, before the current function exits? If so,how?

Freeing alloca-allocated memory

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

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

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

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

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

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

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

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

在当前函数退出之前，是否可以显式地释放由C的alloca()分配的内存？如果是这样的话，是怎么做的？

问释放alloca分配的内存
EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问释放alloca分配的内存EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问释放alloca分配的内存
EN