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. 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;
Fortran 90 The equivalent
Fortran 90 function is 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 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)::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
C Certain
C language standards require support for variable-length arrays. Variable-length arrays were never part of the
C++ language standard. 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 readAndProcess() returns. float readAndProcess(int n) { float vals[n]; for (int i = 0; i In C99, the length parameter must come before the variable-length array parameter in function calls. The C23 standard makes VLA types mandatory again. Only creation of VLA objects with automatic storage duration is optional. 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. With the Linux 4.20 kernel, the
Linux kernel is effectively VLA-free. 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. 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. • include • include float readAndProcess(int n) { float (*vals)[n] = malloc(sizeof(float[n])); for (int i = 0; i
C++ While
C++ does not support stack-allocated variable length arrays (unlike C which does), they may be allowed by some compiler extensions such as on
GCC and
Clang. Otherwise, an array is instead heap-allocated, however a collection type such as std::vector is probably better. This is because the existing collection types in C++ automatically use "
resource acquisition is initialization" (RAII), and will automatically de-allocate once going out of scope. int* createIntArray(size_t n) { return new int[n]; } int main(int argc, char* argv[]) { int* a = createIntArray(5); // do something with the array delete[] a; }
C# The following
C# 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. unsafe void DeclareStackBasedArrayUnsafe(int size) { int* p = stackalloc int[size]; p[0] = 123; } C# version 7.2 and later allow the array to be allocated without the "unsafe" keyword, through the use of the System.Span feature. using System; void DeclareStackBasedArraySafe(int size) { Span a = stackalloc int[size]; a[0] = 123; }
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: 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. The
COBOL 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.
Java Java fixes the size of arrays once they are created, but their size can be determined at runtime. public class Example { public static int[] createIntArray(int size) { return new int[size]; } public static void main(String[] args) { try { String s = IO.readln("Input an integer for an array size: "); int size = Integer.parseInt(s); int[] a = createArray(size); System.out.printf("int[] of size %d created", size); } catch (NumberFormatException e) { System.err.printf("Invalid integer read: %s%n", e.getMessage()); } } }
Object Pascal Object Pascal dynamic arrays are allocated on the heap. 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. program CreateDynamicArrayOfNumbers(Size: Integer); var NumberArray: array of LongWord; begin SetLength(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==