Variable-length array

In computer programming, a variable-length array (VLA), also called variable-sized or runtime-sized, is an array data structure whose length is determined at run time (instead of at compile time). ^[1] In C, the VLA is said to have a variably modified type that depends on a value (see Dependent type).

The main purpose of VLAs is to simplify programming of numerical algorithms.

Programming languages that support VLAs include Ada, Algol 68 (for non-flexible rows), APL, C99 (although subsequently relegated in C11 to a conditional feature, which implementations are not required to support; ^{[2] [3]} on some platforms, VLAs could be implemented previously with alloca() or similar functions) and C# (as unsafe-mode stack-allocated arrays), COBOL, Fortran 90, J, and Object Pascal (the language used in Borland Delphi and Lazarus, that uses FPC).

Growable arrays (also called dynamic arrays) are generally more useful than VLAs because dynamic arrays can do everything VLAs can do, and also support growing the array at run-time. For this reason, many programming languages (JavaScript, Java, Python, R, etc.) only support growable arrays. Even in programming languages that do support variable-length arrays, it's often recommended to avoid using (stack-based) variable-length arrays, and instead use (heap-based) dynamic arrays. ^[4]

Memory

Allocation

• The GNU C Compiler allocates memory for VLAs with automatic storage duration on the stack. ^[5] This is the faster and more straightforward option compared to heap-allocation, and is used by most compilers.
• VLAs can also be allocated on the heap and internally accessed using a pointer to this block.

Implementation

C99

The following C99 function allocates a variable-length array of a specified size, fills it with floating-point values, and then passes it to another function for processing. Because the array is declared as an automatic variable, its lifetime ends when read_and_process() returns.

floatread_and_process(intn){floatvals[n];for(inti=0;i<n;++i)vals[i]=read_val();returnprocess(n,vals);}

In C99, the length parameter must come before the variable-length array parameter in function calls. ^[1] In C11, a __STDC_NO_VLA__ macro is defined if VLA is not supported. ^[6] The C23 standard makes VLA types mandatory again. Only creation of VLA objects with automatic storage duration is optional. ^[7] GCC had VLA as an extension before C99, one that also extends into its C++ dialect.

Linus Torvalds has expressed his displeasure in the past over VLA usage for arrays with predetermined small sizes because it generates lower quality assembly code. ^[8] With the Linux 4.20 kernel, the Linux kernel is effectively VLA-free. ^[9]

Although C11 does not explicitly name a size-limit for VLAs, some believe it should have the same maximum size as all other objects, i.e. SIZE_MAX bytes. ^[10] However, this should be understood in the wider context of environment and platform limits, such as the typical stack-guard page size of 4 KiB, which is many orders of magnitude smaller than SIZE_MAX.

It is possible to have VLA object with dynamic storage by using a pointer to an array.

floatread_and_process(intn){float(*vals)[n]=malloc(sizeof(float[n]));for(inti=0;i<n;++i)(*vals)[i]=read_val();floatret=process(n,*vals);free(vals);returnret;}

Ada

The following is the same example in Ada. Ada arrays carry their bounds with them, so there is no need to pass the length to the Process function.

typeVals_Typeisarray(Positiverange<>)ofFloat;functionRead_And_Process(N: Integer)returnFloatisVals:Vals_Type(1..N);beginforIin1..NloopVals(I):=Read_Val;endloop;returnProcess(Vals);endRead_And_Process;

Fortran 90

The equivalent Fortran 90 function is

function read_and_process(n)result(o)integer,intent(in)::nreal::oreal,dimension(n)::valsinteger::ido i=1,nvals(i)=read_val()end doo=process(vals)end function read_and_process

when utilizing the Fortran 90 feature of checking procedure interfaces at compile time; on the other hand, if the functions use pre-Fortran 90 call interface, the (external) functions must first be declared, and the array length must be explicitly passed as an argument (as in C):

function read_and_process(n)result(o)integer,intent(in)::nreal::oreal,dimension(n)::valsreal::read_val,processinteger::ido i=1,nvals(i)=read_val()end doo=process(vals,n)end function read_and_process

Cobol

The following COBOL fragment declares a variable-length array of records DEPT-PERSON having a length (number of members) specified by the value of PEOPLE-CNT:

DATADIVISION.WORKING-STORAGESECTION.01  DEPT-PEOPLE.05  PEOPLE-CNTPIC S9(4)BINARY.05  DEPT-PERSONOCCURS0 TO20 TIMESDEPENDINGONPEOPLE-CNT.10  PERSON-NAMEPIC X(20).10  PERSON-WAGEPIC S9(7)V99PACKED-DECIMAL.

The COBOL VLA, unlike that of other languages mentioned here, is safe because COBOL requires one to specify the maximal array size – in this example, DEPT-PERSON cannot have more than 20 items, regardless of the value of PEOPLE-CNT.

C#

The following C# fragment declares a variable-length array of integers. Prior to C# version 7.2, a pointer to the array is required, requiring an "unsafe" context. The "unsafe" keyword requires an assembly containing this code to be marked as unsafe.

unsafevoidDeclareStackBasedArrayUnsafe(intsize){int*pArray=stackallocint[size];pArray[0]=123;}

C# version 7.2 and later allow the array to be allocated without the "unsafe" keyword, through the use of the Span feature. ^[11]

voidDeclareStackBasedArraySafe(intsize){Span<int>stackArray=stackallocint[size];stackArray[0]=123;}

Object Pascal

Object Pascal dynamic arrays are allocated on the heap. ^[12]

In this language, it is called a dynamic array. The declaration of such a variable is similar to the declaration of a static array, but without specifying its size. The size of the array is given at the time of its use.

programCreateDynamicArrayOfNumbers(Size:Integer);varNumberArray:arrayofLongWord;beginSetLength(NumberArray,Size);NumberArray[0]:=2020;end.

Removing the contents of a dynamic array is done by assigning it a size of zero.

...SetLength(NumberArray,0);...

References

1. "Variable Length Arrays". Archived from the original on 2018-01-26.
2. "Variable Length – Using the GNU Compiler Collection (GCC)".
3. ISO 9899:2011 Programming Languages – C 6.7.6.2 4.
4. Eric S. Raymond. "Software Release Practice HOWTO: 6. Good development practice". 2000.
5. "Code Gen Options - The GNU Fortran Compiler".
6. § 6.10.8.3 of the C11 standard (n1570.pdf)
7. § 6.10.9.3 of the C23 standard (n3054.pdf)
8. Torvalds, Linus (7 March 2018). "LKML: Linus Torvalds: Re: VLA removal (was Re: [RFC 2/2] lustre: use VLA_SAFE)". Linux kernel (Mailing list).
9. "The Linux Kernel Is Now VLA-Free: A Win For Security, Less Overhead & Better For Clang - Phoronix". www.phoronix.com.
10. §6.5.3.4 and §7.20.3 of the C11 standard (n1570.pdf)
11. "stackalloc operator (C# reference)". Microsoft.
12. Michaël Van Canneyt. "Free Pascal Reference guide: Dynamic arrays".