动态数组（GCC）和指针之间的区别

Question

Considering following pieces of code:

void foo() {
    int arraySize = getMyComputedValue();
    int dynamicArray[arraySize];

    fillDynamicArray(&dynamicArray[0]);

    for (int i = 0; i < arraySize; i++) {
        // Do something with data
    }
}

void bar() {
    int arraySize = getMyComputedValue();
    int* dynamicArray = new int[arraySize];

    fillDynamicArray(dynamicArray);

    for (int i = 0; i < arraySize; i++) {
        // Do something with data
    }

    delete[] dynamicArray;
    dynamicArray = NULL;
}

Both create a dynamic area in memory with varying lengths containing integers. I've found that the first example foo() (at least in my build environment) only compiles with GCC.

What are the exact differences between the two? Is the first example merely a GNU extension which is shorthand for the bottom example, allowing the compiler to determine when the correct time for de-allocation is? Or does the first example do exactly as the code says and allocates the memory on the stack?

Answer 1

1. foo() allocates the memory on the stack, bar() allocates it on the heap. This has two effects: Lifetime (stack memory is automatically reclaimed at function exit), and max array size (stack space is rather limited to a range of a few MB at most, heap space is only limited by available RAM).

2. foo() is valid C99, but not C++ of any standard. C++ simply never embraced VLAs. This is the core point where you need to realize that C and C++ are two quite distinct languages. There are valid C programs that are not C++ (like foo() ), and there are valid C++ programs that are not C (like bar() ). C++ is not the strict superset anymore as which it started.

Nevertheless, compilers may choose to implement a superset of the language as an extension. g++ does so, but if you compile with strict C++ standard compliance ( g++ -std=c++14 -pedantic -Werror ), even g++ throws an error on foo() .