blocks|key|1389726|text|int+n;++
scanf("\n%25d+",&n);++
int+arr[n];|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1389727|如果它有效，那么这意味着您使用的编译器仍然将其解释为"DMA“，这里唯一的区别是它将在作用域结束时被解除分配，但我不认为这是C的一个好做法。|unstyled|1389728|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>int n; 
scanf("\n%d ",&amp;n); 
int arr[n];
</code></pre>

If it works then that means you are using compiler that still interprets it as "DMA" the only difference here would be that it will get deallocated at the end of the scope but I don't think it's a good practice for C.

blocks|key|1389771|text|int+arr[n];+在堆栈上分配内存.是自动分配，然后在块末尾解除分配。。指向堆栈内存的指针不能安全地从函数返回。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1389772|考虑一下这个。|1389773|#include+<stdio.h>

char+*make_array()+{
++++int+n;++
++++scanf("%25d",&n);

++++//+Memory+for+`arr`+is+allocated+on+the+stack.
++++char+arr[n];

++++//+And+then+deallocated+when+the+function+exits.
++++//+A+good+compiler+and+editor+will+warn+you+if+you+try
++++//+to+return+it.
++++return+arr;
}

int+main()+{
++++//+This+pointer+is+to+memory+which+has+already+been+freed.+Other+things
++++//+will+overwrite+it.
++++char+*arr+=+make_array();

++++arr[0]+=+'c';
++++arr[1]+=+'\0';

++++//+This+could+be+the+letter+c,+but+it's+probably+gibberish.
++++puts(arr);
}|code-block|syntax|javascript|1389774|如果需要内存超过当前函数的生命周期，则需要使用malloc在堆中分配内存并自己管理它。|1389775|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Stack-based_memory_allocation|1|https://en.wikipedia.org/wiki/Automatic_variable^0|0|B|C|8|0|M|G|1|0|0|0|N|6|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@$9|11|A|12|1|13]|$9|14|A|15|1|16]]|E|$]]|$1|F|3|G|5|6|7|17|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|18|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|19|8|@$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]|W|$5|R|S|T|E|$U|X]]]]

<code>int arr[n];</code> <a href="https://en.wikipedia.org/wiki/Stack-based_memory_allocation" rel="nofollow noreferrer">allocates memory on the stack</a>. It is <a href="https://en.wikipedia.org/wiki/Automatic_variable" rel="nofollow noreferrer">automatically allocated and then deallocated at the end of the block</a>. A pointer to stack memory cannot be safely returned from a function.

Consider this.

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

char *make_array() {
 int n; 
 scanf("%d",&amp;n);

 // Memory for `arr` is allocated on the stack.
 char arr[n];

 // And then deallocated when the function exits.
 // A good compiler and editor will warn you if you try
 // to return it.
 return arr;
}

int main() {
 // This pointer is to memory which has already been freed. Other things
 // will overwrite it.
 char *arr = make_array();

 arr[0] = 'c';
 arr[1] = '\0';

 // This could be the letter c, but it's probably gibberish.
 puts(arr);
}
</code></pre>

If you need memory to live beyond the life of the current function, you need to allocate it on the heap with <code>malloc</code> and manage it yourself.

blocks|key|756621|text|只是为了确保你明白：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|756622|当“函数调用函数”时，它们的局部变量存储在一个称为“堆栈”的内存区域中，因为它的工作方式类似于向下推放的LIFO堆栈。输入函数时，堆栈将增长。当函数返回时，它会收缩。如果一个函数递归地调用自己，就不会产生混淆，因为每个实例在堆栈上都有自己的区域。|756623|malloc()“根据请求”从一个名为“堆”的不同区域分配内存，因为它没有特定的内置组织。使用“指针”间接引用这些内存区域，这些变量的值被理解为内存地址。|offset|length|style|CODE|756624|"C“语言允许您在使用指针时使用”数组符号“，就像它使用堆栈上分配的局部变量一样。|756625|entityMap^0|0|0|0|8|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@$F|Q|G|R|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

Just to be sure you understand:

When "functions call functions," their local variables are stored in an area of memory known as "the stack," so named because it works like a push-down LIFO stack. When a function is entered, the stack grows. When the function returns, it shrinks. And if a function recursively calls itself, there's no confusion because each instance has its own area on the stack.

<code>malloc()</code> allocates memory "upon request" from a different area called "the heap," so named because it has no particular built-in organization. These areas of memory are referenced indirectly, using "pointers," which are variables whose value is understood to be a memory address.

The "C" language conveniently allows you to use "array notation" when using pointers, just as it does with local variables that are allocated on the stack.

blocks|key|1600789|text|int+n;++
scanf("\n%25d+",&n);++
int+arr[n];|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1600790|如果n是一个运行时动态值(在本例中是如此)，则C的旧版本不支持它，这要求n是一个整数常量表达式。|unstyled|offset|length|style|CODE|1600791|现代版本的C已经取消了这个限制，允许动态大小的数组(可变长度数组，或VLA)，但是与旧的固定大小数组不同，VLA有限制。|1600792|它们不允许被跳过(对于break/continue/goto)，，它们可能不是异步信号安全的，如果它们太大，它们会使您的程序崩溃，并且它们通常会生成比普通的旧本地数组更大的代码。)|1600793|另外，因为它们是本地的，所以不能将指向调用方的指针返回给调用者。|1600794|尺寸限制是他们最大的限制之一。VLAs是从调用堆栈中分割出来的，调用堆栈通常只有几公斤/兆字节大，如果超过这个限制，就会出现典型的未诊断的崩溃。|1600795|mallocd内存没有这样的限制，malloc故障显然是通过返回的NULL报告的，而且由于mallocd内存对进程是全局的，所以可以将指向它的指针传递给调用方。|1600796|`|1600797|entityMap^0|0|2|1|10|1|0|0|B|5|H|8|Q|4|0|0|0|0|6|H|6|X|4|19|6|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|Z|8|@$G|10|H|11|I|J]|$G|12|H|13|I|J]]|9|@]|A|$]]|$1|K|3|L|5|F|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|15|8|@$G|16|H|17|I|J]|$G|18|H|19|I|J]|$G|1A|H|1B|I|J]]|9|@]|A|$]]|$1|O|3|P|5|F|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|1D|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|1E|8|@$G|1F|H|1G|I|J]|$G|1H|H|1I|I|J]|$G|1J|H|1K|I|J]|$G|1L|H|1M|I|J]]|9|@]|A|$]]|$1|U|3|V|5|F|7|1N|8|@]|9|@]|A|$]]|$1|W|3|-4|5|F|7|1O|8|@]|9|@]|A|$]]]|X|$]]

<pre><code>int n; 
scanf("\n%d ",&amp;n); 
int arr[n];
</code></pre>

where the <code>n</code> is a runtime-dynamic value (as it is in this case) was not supported in older versions of C, which required that the <code>n</code> be an integer constant expression.

Modern versions of C have lifted this limitation, allowing dynamically sized arrays (variable length arrays, or VLAs), but unlike the old fixed-sized arrays, VLAs have restrictions.

They aren't allowed to be jumped across (with <code>break</code>/<code>continue</code>/<code>goto</code>), they might not be be async-signal-safe, they will crash your program if they get too large, and they will often generate larger code than plain old local arrays.

Also, because they're local, you can't return a pointer to them to your caller.

The size limitations is one of their biggest restrictions. VLAs are carved out of the call stack, which is typically only a couple of kilo/mega-bytes large, and you get a typically undiagnosed crash if you exceed this limit.

<code>malloc</code>'d memory doesn't have such a limit, <code>malloc</code> failures are clearly reported via a returned <code>NULL</code>, and because <code>malloc</code>'d memory is global to the process, you can pass a pointer to it back to your caller.

`

Consider these codes in C: 

<pre><code>int n; 
scanf("\n%d ",&amp;n); 
int arr[n];
</code></pre>

and this. 

<pre><code>int n;
scanf("\n%d ",&amp;n);
int *p = (int *)malloc(n*sizeof(int)); 
</code></pre>

Why do we need dynamic memory allocation for this in the first place? 
and is the first code not Dynamic Memory Allocation as the array is created during runtime? 

When should I use malloc()?

Why do we need to use malloc() or any other Dynamic Memory for ARRAYS in C?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

考虑一下C中的这些代码：int n;  scanf("\n%d ",&n);  int arr[n];还有这个。int n;scanf("\n%d ",&n);int *p = (int *)malloc(n*sizeof(int));  为什么我们首先需要动态内存分配？当数组在运行时创建时，第一段代码不是动态内存分配...

问为什么我们需要对C中的数组使用malloc()或任何其他动态内存？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么我们需要对C中的数组使用malloc()或任何其他动态内存？EN