Why Does This C Code Compile Despite a Non-Constant Array Bound?

C Array Bound as Constant Expression: Exception in the Code

In C , an array bound must typically be a constant expression, ensuring that the size of the array is known during compilation. However, in certain cases, this rule seems to be violated. Let's explore a specific example:

#include <iostream>
using namespace std;

int main() {
    int n = 10;
    int a[n];  // Array a with size n

    for (int i = 0; i < n; i++) {
        a[i] = i + 1;
        cout << a[i] << endl;
    }

    return 0;
}

This code, when compiled using Xcode4 on Mac, executes without any errors. Despite the fact that the size of the array a is not a constant expression, the code works.

Explanation: Variable-Length Arrays (VLA)

The reason this code works is due to a feature called Variable-Length Arrays (VLA), which was introduced in C99. VLAs allow the size of an array to be determined at runtime, unlike regular arrays whose size must be known at compile time.

In the provided code, n is not a constant expression but a variable. However, since the compiler in Xcode4 supports VLA, it is able to allocate memory for the array a during runtime based on the value of n.

Stack Allocation vs. Heap Allocation

It's important to note that VLAs are allocated on the stack, similar to static arrays. This means that the memory for the array is allocated and freed automatically as the program enters and exits the function where the VLA is declared. This behavior is different from regular arrays that are allocated on the heap and must be manually managed using pointers.

The above is the detailed content of Why Does This C Code Compile Despite a Non-Constant Array Bound?. For more information, please follow other related articles on the PHP Chinese website!