静态、堆栈和堆分配有何不同？

Question

How can i declare an array like this one:

int array[1000000];

as a static array, a stack array, and a heap-allocated array?

Answer 1

Your assignment appears to be looking for this:

// global variable; NOT on the stack. Exists in the data segment of the program
int globalvar[1000000];

void func()
{
    // local stack-variable. allocated on the stack on function entry
    //  unavailable outside this function scope.
    int stackvar[1000000];

    // allocated on the heap. the only stack space used in the
    //  space occupied by the pointer variable.
    int *heapvar = malloc(1000000 * sizeof(int));
    if (heapvar != NULL)
    {
        // use heap var

        // free heap var
        free(heapvar)
    }
}

Or perhaps this:

void func()
{
    // static variable; NOT on the stack. Exists in a program data segment (usually)
    static int staticvar[1000000];
    
    // local stack-variable. allocated on the stack on function entry
    //  unavailable outside this function scope.
    int stackvar[1000000];

    // allocated on the heap. the only stack space used in the
    //  space occupied by the pointer variable.
    int *heapvar = malloc(1000000 * sizeof(int));
    if (heapvar != NULL)
    {
        // use heap var

        // free heap var
        free(heapvar)
    }
}

For what it is worth, unless you have a four or eight megabyte reserved call-stack (or larger), the function above will likely croak on entry. For such large sizes it is customary to use the heap ( malloc() / free() ). But that is not what your assignment appears to be about (yet).

Answer 2

A static declaration inside functions means, that the declared variable is shared among executions of the function it is declared in. The stack is a place in memory that may be used by whatever function is running right now; there is no way to protect an area on the stack from being overwritten while your function is not running. Static variables are usually stored either in the data or if unitialized into the bss section of your program. If you have the strict requirement to have the array in the stack, you could try copying it:

void foo(void) {
   static int my_static_array[16];
   int array_copy[16];

   memcpy(array_copy,my_static_array,sizeof array_copy);

   /* do funny stuff */

   memcpy(my_static_array,array_copy,sizeof my_static_array);
}

Answer 3

A static variable cannot be on the stack, this is because static and local variables are fundamentally different, with local variables "living" in the stack while static variables "living" in the static segment. If you want a local variable to be visible to a function called by the function in which the local variable is declared, then you should pass that local variable as an argument. an other solution not recommended is to have a static pointer to an array and have it point to the array existing in the stack, this will work as long as the function in which the local array is declared, has not returned. After returning though the pointer will point to an area that other data may exist meaning that it is possible to overwrite a return address or an irrelevant local variable or function argument.

Answer 4

如果你想让它公开array ，你可以在任何范围之外（在代码块之外）定义它，它将在二进制文件的文本段上声明。