Variable-length array

<h2 id="memory">Memory</h2>
<h3>Allocation</h3>
<ul><li>The <a href="/facts/GNU_Compiler_Collection/t07jh01k">GNU Compiler Collection</a> (GCC) for C allocates memory for VLAs with <a href="/facts/Automatic_variable/S6KdHa7p">automatic storage duration</a> on the <a href="/facts/Stack-based_memory_allocation/Wem3dQa6">stack</a>.<a class="footnote-ref" id="fnref:5" href="#fn:5"><sup>5</sup></a> This is the faster and more straightforward option compared to heap-allocation, and is used by most compilers.</li>
<li>VLAs can also be allocated on the <a href="/facts/Memory_management/vthLkUpz">heap</a> and internally accessed using a pointer to this block.</li></ul>
<h2 id="implementation">Implementation</h2>
<h3>C99</h3>
<p>The following <a href="/facts/C99/o5uMWjTQ">C99</a> 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.
</p>
float read_and_process(int n)
{
    float vals[n];

for (int i = 0; i < n; ++i)
        vals[i] = read_val();

return process(n, vals);
}

<p>In C99, the length parameter must come before the variable-length array parameter in function calls.<a class="footnote-ref" id="fnref:6" href="#fn:6"><sup>6</sup></a> In C11, a __STDC_NO_VLA__ macro is defined if VLA is not supported.<a class="footnote-ref" id="fnref:7" href="#fn:7"><sup>7</sup></a> The C23 standard makes VLA types mandatory again. Only creation of VLA objects with automatic storage duration is optional.<a class="footnote-ref" id="fnref:8" href="#fn:8"><sup>8</sup></a> GCC had VLA as an extension before C99, one that also extends into its C++ dialect.
</p><p><a href="/facts/Linus_Torvalds/EdDKP534">Linus Torvalds</a> has expressed his displeasure in the past over VLA usage for arrays with predetermined small sizes because it generates lower quality assembly code.<a class="footnote-ref" id="fnref:9" href="#fn:9"><sup>9</sup></a> With the Linux 4.20 kernel, the <a href="/facts/Linux_kernel/dlkduHuA">Linux kernel</a> is effectively VLA-free.<a class="footnote-ref" id="fnref:10" href="#fn:10"><sup>10</sup></a>
</p><p>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.<a class="footnote-ref" id="fnref:11" href="#fn:11"><sup>11</sup></a> 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.
</p><p>It is possible to have VLA object with dynamic storage by using a pointer to an array.
</p>
float read_and_process(int n)
{
    float (*vals)[n] = malloc(sizeof(float[n]));

for (int i = 0; i < n; ++i)
        (*vals)[i] = read_val();

float ret = process(n, *vals);
    
    free(vals);
    
    return ret;
}

<h3>Ada</h3>
<p>The following is the same example in <a href="/facts/Ada_(programming_language)/Y2yHel4l">Ada</a>. Ada arrays carry their bounds with them, so there is no need to pass the length to the Process function.
</p>
type Vals_Type is array (Positive range <>) of Float;

function Read_And_Process (N : Integer) return Float is
   Vals : Vals_Type (1 .. N);
begin
   for I in 1 .. N loop
      Vals (I) := Read_Val;
   end loop;
   return Process (Vals);
end Read_And_Process;

<h3>Fortran 90</h3>
<p>The equivalent <a href="/facts/Fortran/m1KqjcMU">Fortran 90</a> function is
</p>
function read_and_process(n) result(o)
    integer,intent(in)::n
    real::o

real,dimension(n)::vals
    integer::i

do i = 1,n
       vals(i) = read_val()
    end do
    o = process(vals)
end function read_and_process

<p>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):
</p>
function read_and_process(n) result(o)
    integer,intent(in)::n
    real::o

real,dimension(n)::vals
    real::read_val, process
    integer::i

do i = 1,n
       vals(i) = read_val()
    end do
    o = process(vals,n)
end function read_and_process

<h3>Cobol</h3>
<p>The following <a href="/facts/COBOL/wVnhqs0k">COBOL</a> fragment declares a variable-length array of records DEPT-PERSON having a length (number of members) specified by the value of PEOPLE-CNT:
</p>
DATA DIVISION.
WORKING-STORAGE SECTION.
01  DEPT-PEOPLE.
    05  PEOPLE-CNT          PIC S9(4) BINARY.
    05  DEPT-PERSON         OCCURS 0 TO 20 TIMES DEPENDING ON PEOPLE-CNT.
        10  PERSON-NAME     PIC X(20).
        10  PERSON-WAGE     PIC S9(7)V99 PACKED-DECIMAL.

<p>The <a href="/facts/COBOL/wVnhqs0k">COBOL</a> VLA, unlike that of other languages mentioned here, is safe because COBOL requires specifying maximum array size. In this example, DEPT-PERSON cannot have more than 20 items, regardless of the value of PEOPLE-CNT.
</p>
<h3>C#</h3>
<p>The following <a href="/facts/C_Sharp_(programming_language)/UC2gxeyb">C#</a> fragment declares a variable-length array of integers. Before 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.
</p>
unsafe void DeclareStackBasedArrayUnsafe(int size)
{
    int *pArray = stackalloc int[size];
    pArray[0] = 123;
}

<p>C# version 7.2 and later allow the array to be allocated without the "unsafe" keyword, through the use of the Span feature.<a class="footnote-ref" id="fnref:12" href="#fn:12"><sup>12</sup></a>
</p>
void DeclareStackBasedArraySafe(int size)
{
    Span<int> stackArray = stackalloc int[size];
    stackArray[0] = 123;
}

<h3>Object Pascal</h3>
<p><a href="/facts/Object_Pascal/cuGkuISv">Object Pascal</a> dynamic arrays are allocated on the heap.<a class="footnote-ref" id="fnref:13" href="#fn:13"><sup>13</sup></a>
</p><p>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.
</p>
program CreateDynamicArrayOfNumbers(Size: Integer);
var
  NumberArray: array of LongWord;
begin
  SetLength(NumberArray, Size);
  NumberArray[0] := 2020;
end.

<p>Removing the contents of a dynamic array is done by assigning it a size of zero.
</p>
...
SetLength(NumberArray, 0);
...

<h2 id="references">References</h2>

<ol>
<li id="fn:1"><p>"Variable Length Arrays". Archived from the original on 2018-01-26. <a href="https://web.archive.org/web/20180126153326/http://docs.cray.com/books/004-2179-001/html-004-2179-001/z893434830malz.html" target="_blank">https://web.archive.org/web/20180126153326/http://docs.cray.com/books/004-2179-001/html-004-2179-001/z893434830malz.html</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></p></li>
<li id="fn:2"><p>"Variable Length – Using the GNU Compiler Collection (GCC)". <a href="https://gcc.gnu.org/onlinedocs/gcc/Variable-Length.html" target="_blank">https://gcc.gnu.org/onlinedocs/gcc/Variable-Length.html</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></p></li>
<li id="fn:3"><p>ISO 9899:2011 Programming Languages – C 6.7.6.2 4. <a href="#fnref:3" class="footnote-back-ref">↩</a></p></li>
<li id="fn:4"><p>Raymond, Eric S. (2000). "Raymond Software Release Practice Howto: 6. Good development practice". The Linux Documentation Project. <a href="https://tldp.org/HOWTO/Software-Release-Practice-HOWTO/develpractice.html" target="_blank">https://tldp.org/HOWTO/Software-Release-Practice-HOWTO/develpractice.html</a> <a href="#fnref:4" class="footnote-back-ref">↩</a></p></li>
<li id="fn:5"><p>"Code Gen Options - The GNU Fortran Compiler". <a href="https://gcc.gnu.org/onlinedocs/gfortran/Code-Gen-Options.html" target="_blank">https://gcc.gnu.org/onlinedocs/gfortran/Code-Gen-Options.html</a> <a href="#fnref:5" class="footnote-back-ref">↩</a></p></li>
<li id="fn:6"><p>"Variable Length Arrays". Archived from the original on 2018-01-26. <a href="https://web.archive.org/web/20180126153326/http://docs.cray.com/books/004-2179-001/html-004-2179-001/z893434830malz.html" target="_blank">https://web.archive.org/web/20180126153326/http://docs.cray.com/books/004-2179-001/html-004-2179-001/z893434830malz.html</a> <a href="#fnref:6" class="footnote-back-ref">↩</a></p></li>
<li id="fn:7"><p>§ 6.10.8.3 of the C11 standard (n1570.pdf) <a href="#fnref:7" class="footnote-back-ref">↩</a></p></li>
<li id="fn:8"><p>§ 6.10.9.3 of the C23 standard (n3054.pdf) <a href="#fnref:8" class="footnote-back-ref">↩</a></p></li>
<li id="fn:9"><p>Torvalds, Linus (7 March 2018). "LKML: Linus Torvalds: Re: VLA removal (was Re: [RFC 2/2] lustre: use VLA_SAFE)". Linux kernel (Mailing list). <a href="/wiki/Linus_Torvalds" target="_blank">/wiki/Linus_Torvalds</a> <a href="#fnref:9" class="footnote-back-ref">↩</a></p></li>
<li id="fn:10"><p>"The Linux Kernel Is Now VLA-Free: A Win For Security, Less Overhead & Better For Clang - Phoronix". www.phoronix.com. <a href="https://www.phoronix.com/scan.php?page=news_item&px=Linux-Kills-The-VLA" target="_blank">https://www.phoronix.com/scan.php?page=news_item&px=Linux-Kills-The-VLA</a> <a href="#fnref:10" class="footnote-back-ref">↩</a></p></li>
<li id="fn:11"><p>§6.5.3.4 and §7.20.3 of the C11 standard (n1570.pdf) <a href="#fnref:11" class="footnote-back-ref">↩</a></p></li>
<li id="fn:12"><p>"stackalloc operator (C# reference)". Microsoft. 10 July 2024. <a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/stackalloc" target="_blank">https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/stackalloc</a> <a href="#fnref:12" class="footnote-back-ref">↩</a></p></li>
<li id="fn:13"><p>Michaël Van Canneyt.
"Free Pascal Reference guide: Dynamic arrays". <a href="https://www.freepascal.org/docs-html/ref/refsu14.html#x38-520003.3.1" target="_blank">https://www.freepascal.org/docs-html/ref/refsu14.html#x38-520003.3.1</a> <a href="#fnref:13" class="footnote-back-ref">↩</a></p></li>
</ol>

Variable-length array open-in-new

Variable-length array