Given the following code snippet in C: int* x; x = (int *) malloc(40); We know that this is an explicit heap dynamic allocation. If I change the code to this though: int* x = (int *) malloc(40); is it still an explicit heap dynamic? My friend thinks it's a stack dynamic, but I think its an explicit heap dynamic because we're allocating memory from the heap. Explicit heap dynamic
鉴于C中的以下代码片段： int* x; x = (int *) malloc(40); 我们知道这是一个明确的堆动态分配。 如果我将代码更改为此： int* x = (int *) malloc(40); 它仍然是一个明确的堆动态？ 我的朋友认为这是一个动态堆栈，但我认为它是一个明确的堆动态，因为我们从堆中分配内存。 显式堆动态定义为由编程人员编写的显式运行时指令分配和释放的变量。 这不意味着任何malloc / calloc调用将是明确的堆？ 编辑：我和我的教授
I was playing up with malloced memory and local variables to see how stack and Heap grows. From my understanding heap grows upwards and the stack grows downwards. All the memory allocated using malloc is allocated in the heap and local variables are allocated on the stack in a function. In following program : #include <stdio.h> #include <stdlib.h> #define SIZE 999999999 void tot(
我正在玩malloced内存和局部变量，以查看堆栈和堆的增长情况。 根据我的理解，堆向上生长，堆栈向下生长。 所有使用malloc分配的内存都分配在堆中，并且局部变量在堆栈中分配到一个函数中。 在以下程序中： #include <stdio.h> #include <stdlib.h> #define SIZE 999999999 void tot(){ static int c =0; int k; c++; int *pp = malloc(sizeof(int) * SIZE); if(pp==NULL){ fprintf
I read that pointers passed by malloc() & calloc() get allocated memory dynamically from the heap. char *Name="Ann"; In this case, is the static string {'A','n','n',''} also stored in the heap? Can I modify the string using the pointer? No, the string is allocated statically. (C99, §6.4.5/5) Attempting to modify a string literal gives undefined behavio
我读过由malloc（）和calloc（）传递的指针从堆中动态分配内存。 char *Name="Ann"; 在这种情况下，静态字符串{'A'，'n'，'n'，' 0'}是否也存储在堆中？ 我可以使用指针修改字符串吗？ 不，该字符串是静态分配的。 （C99，§6.4.5/ 5） 尝试修改字符串文字会导致未定义的行为。 （§6.4.5/ 6）
In C, I know I can dynamically allocate a two-dimensional array on the heap using the following code: int** someNumbers = malloc(arrayRows*sizeof(int*)); for (i = 0; i < arrayRows; i++) { someNumbers[i] = malloc(arrayColumns*sizeof(int)); } Clearly, this actually creates a one-dimensional array of pointers to a bunch of separate one-dimensional arrays of integers, and "The System&q
在C中，我知道我可以使用下面的代码动态地在堆上分配一个二维数组： int** someNumbers = malloc(arrayRows*sizeof(int*)); for (i = 0; i < arrayRows; i++) { someNumbers[i] = malloc(arrayColumns*sizeof(int)); } 显然，这实际上创建了一个指向一组单独的一维整数数组的指针数组，“系统”可以找出我的意思，当我要求： someNumbers[4][2]; 但是，当我静态声明一个二维数组，如下面的行......： int someNumbers[
I wonder where constant variables are stored. Is it in the same memory area as global variables? Or is it on the stack? How they are stored is an implementation detail (depends on the compiler). For example, in the GCC compiler, on most machines, read-only variables, constants, and jump tables are placed in the text section. Depending on the data segmentation that a particular processor f
我想知道常量变量的存储位置。 它和全局变量在同一个内存区域吗？ 或者它在堆栈上？ 它们如何存储是一个实现细节（取决于编译器）。 例如，在GCC编译器中，在大多数机器上，只读变量，常量和跳转表位于文本部分。 根据特定处理器所遵循的数据分段，我们有五个分段： 代码段 - 仅存储代码，ROM BSS（或由符号启动的块）段 - 存储初始化的全局变量和静态变量 堆栈段 - 存储关于函数返回地址等的所有本地变量和其他信
It is known the prototype for main funcion in C is int main(int argc, char **argv) . Where do those strings pointed by argv array reside? Which memory segment are they in? Data, stack or heap? Thanks. Under Linux they are on the stack when the program starts, both the pointers themselves and the strings they point to. This will be somewhere up above main() 's stack frame. The C libra
众所周知，C中main funcion的原型是int main(int argc, char **argv) 。 argv数组指向的那些字符串在哪里？ 他们在哪个内存段？ 数据，堆栈还是堆？ 谢谢。 在Linux下，它们在程序启动时位于堆栈上，指针本身和它们指向的字符串。 这将会在main()的堆栈框架之上。 C库启动代码负责将适当的指针传递给main() 。 您可以在函数create_elf_tables()中的fs/binfmt_elf.c中找到设置新程序堆栈的内核代码，包括参数和其他所
#include <stdio.h> main() { int i = 5; printf("%d n" , &i); } 重复执行上述程序是否会导致变量i地址不同？ Yes it can. Here's an explanation from a similar question: It signifies that your program is being loaded a different (virtual) address each time you run it. This is a feature called Address Space Layout Randomization (ASLR) and is a feature of most modern operating s
#include <stdio.h> main() { int i = 5; printf("%d n" , &i); } 重复执行上述程序是否会导致变量i地址不同？ 是的，它可以。 以下是一个类似问题的解释： 它表示您的程序每次运行时都会加载一个不同的（虚拟）地址。 这是一个称为地址空间布局随机化（ASLR）的功能，是大多数现代操作系统的一项功能。 从这里开始：为什么在C中每次执行后变量的地址变化？ 是的，它会改变！ 指针用于存储变量的地
If, for example, I have a small function: int sum(int a, int b) { int result = a+b; return result; } Here, the result is a local variable which, from what I understand, should live only for the execution time of the function. How is the caller of this function able to retrieve the return value of the sum() function, which is nothing but the value of the local variable result ? Just want
例如，如果我有一个小功能： int sum(int a, int b) { int result = a+b; return result; } 这里的result是一个局部变量，根据我的理解，这个局部变量只适用于函数的执行时间。 这个函数的调用者如何能够检索sum（）函数的返回值，这只是局部变量result的值？ 只是想知道函数中声明的局部变量的值是如何返回给调用者函数的。 我知道这发生在堆栈中，但我想知道它是如何发生的。 return result; 不返回result的变量
This question already has an answer here: Identifying data type of a value in memory in C? 5 answers There is no need for the memory to know what type of data is being stored and where. Memory is just about storing values in blocks with addresses. Its the compilers job to determine the type and fetch the appropriate data from memory. suppose i have this value stored in my memory how wil
这个问题在这里已经有了答案： 在C中识别内存中的值的数据类型？ 5个答案 内存不需要知道存储的数据类型和位置。 内存仅仅是将地址块中的值存储起来。 编译器的工作是确定类型并从内存中获取适当的数据。 假设我将这个值存储在我的内存中，内存如何确定这是字符串还是int 它没有。 数据类型如何存储在内存中 如果存储了类型信息，以及如何完全达到所用的编程语言和运行时环境。 我知道C（编译器和标准库）的所
I am using GCC 4.8.1 and it doesn't seem to store const variable local to main in DATA segment. Below is code and memory map for 3 such programs: Code 1: int main(void) { //char a[10]="HELLO"; //1 //const char a[10] = "HELLO"; //2 return 0; } MEMORY MAP FOR ABOVE: text data bss dec hex filename 7264 1688 1040 9992 2708 a.exe CODE 2: int main(void) {
我正在使用GCC 4.8.1，它似乎没有将常量变量局部存储到数据段中的main。 下面是3个这样的程序的代码和内存映射： 代码1： int main(void) { //char a[10]="HELLO"; //1 //const char a[10] = "HELLO"; //2 return 0; } MEMORY MAP FOR ABOVE: text data bss dec hex filename 7264 1688 1040 9992 2708 a.exe 代码2： int main(void) { char a[10]="HELLO"; //const char a[1