Variable size arrays (VLAs) are not forbidden in C ; the iso error is correct. Runtime-sized or variable-sized arrays are the other names for variable-length arrays. The size of these arrays is set at runtime. Among the kinds that can be updated are variable-length arrays and pointers to variable-length arrays. Variably modified types should be defined at either the block or function prototype level. Variable-length arrays are a feature that allows us to allocate a variable-size auto array on the stack. In a typedef statement, it can be utilized. From the C standard onwards, C enables variable-size arrays. The program below, for example, compiles and runs perfectly in C.
void PrintArray(int n)
{
int Array[n];
// ……
}
int main()
{
PrintArray(8);
}
However, variable-sized arrays are not supported by the C standard (until C 11). Array size is a constant expression in the C 11 standard. As a result, the above program may not be an acceptable C program. As the GCC compiler has an extension to accommodate them, the program may function with the GCC compiler. As little more, the array size is now a simple expression in C 14 (not constant-expression).
It’s not desirable to have to generate a potentially big array on a stack with limited space. If you are not aware ahead of time, we will write damaging code. Variable-length arrays are not natively supported in C because they would necessitate significant type system changes.
Here, in the C article, we will show how to overcome the C iso forbidden variable-length array error at the compilation time.
Example 1: Program to Implement a variable-length array in C With GCC Compiler
Variable-length arrays can choose any size that the user desires, i.e., they can be variable in size. The following is a C program for creating variable-length arrays:
We have C header files in the first step and the namespace file. After that, we have the program main method, and the main body has the pointer variable declaration as “Array” and the other variable “Arr_Size” declaration. The cout prints the statement that asks the user a number for array size. Then, cin will take the number value from the user. The variable “Array” is called where we have set the size of the array.
Now, we have also requested the array values from the user. The array value will iterate by the for loop till it reaches the array size. Then, the second for loop is used to print the values inside the array, and at the same time, we have deleted the array by using the delete[] expression in the program.
#include
#include
using namespace std;
int main() {
int *Array, Arr_size;
cout<<“Enter array size: “Arr_size;
Array = new int [Arr_size];
cout<<“Enter array values: “<<endl;
for (int i = 0; i>Array[i];
cout<<“Array: “;
for(int i = 0; i<Arr_size; i )
cout<<Array[i]<<” “;
cout<<endl;
return 0;
}
<img data-lazy- data-lazy-src="https://kirelos.com/wp-content/uploads/2022/06/echo/word-image-22.jpeg" data-lazy- height="400" src="data:image/svg xml,” width=”615″>
The shell displays a message for inputting the array size after compilation. When the user input the size of the array then, the shell asks the user to set the values for the array. The size of the array and its elements are accessible as follows. Hence, we can implement a variable-length array in C without a forbidden exception.
<img data-lazy- data-lazy-src="https://kirelos.com/wp-content/uploads/2022/06/echo/word-image-23.jpeg" data-lazy- height="254" src="data:image/svg xml,” width=”608″>
Example 2: Program to Implement a variable-length array in C by Using Vectors
The C STL provides a vector as an alternative to variable-length arrays. It’s suitable for a variety of applications. It will be more clear with the C program, which we have implemented below.
As we have to use vectors in our program. So the most important part is to define the vector as a header file at the top of the code implementation. We have added the vector file in the section of the header.
Within the program main, we have a vector class with type int, and the vectors class has a variable “v.” We have added five elements of type integer in the vector. After that, we have a for loop iteration cycle. Inside the for loop, we have declared an iterator to a vector with a new variable “it.” Then, the “it” variable has a begin and end function for displaying the elements of the vectors.
#include
#include
using namespace std;
int main() {
vector v;
v.push_back(10);
v.push_back(20);
v.push_back(30);
v.push_back(40);
v.push_back(50);
for(vector::iterator it = v.begin(); it != v.end(); it ) {
cout<< *it <<endl;
}
return 0;
}
<img data-lazy- data-lazy-src="https://kirelos.com/wp-content/uploads/2022/06/echo/word-image-24.jpeg" data-lazy- height="323" src="data:image/svg xml,” width=”670″>
The above program gives the output like this.
<img data-lazy- data-lazy-src="https://kirelos.com/wp-content/uploads/2022/06/echo/word-image-25.jpeg" data-lazy- height="169" src="data:image/svg xml,” width=”637″>
Example 3: Program to Implement a variable-length array in C by Using std:: vector
Vectors are used to carry comparable data types in C . The size of a vector, unlike arrays, can grow dynamically. We can adjust the vector size as needed throughout the program execution. The vector header file must be included in our program to utilize vectors. Once the vector library is included in the header file, we can utilize vector as std::vector in the program.
After including the vector library at the top, we have called the std::vector inside the program’s main function. The vector is declared as “numbers” and initialized with the five random numeric values. The variable “number” is again defined, which has three vector elements from the above-given vector container. The std::cout is used to display the length of the vector inside the variable “number” by using the size function.
#include
#include
int main()
{
std::vector numbers = {10, 20, 30, 40, 50};
numbers = {30, 40, 50};
std::cout<< “Array Length : “ <<numbers.size() << std::endl;
return 0;
}
<img data-lazy- data-lazy-src="https://kirelos.com/wp-content/uploads/2022/06/echo/word-image-26.jpeg" data-lazy- height="198" src="data:image/svg xml,” width=”686″>
The output shows the length of the specified vector array as follows.
<img data-lazy- data-lazy-src="https://kirelos.com/wp-content/uploads/2022/06/echo/word-image-27.jpeg" data-lazy- height="85" src="data:image/svg xml,” width=”647″>
Conclusion
Summing up! Here, we have a detailed discussion about variable-length arrays in the introduction. Thus, we learned that C forbids variable-length arrays(VLA). We have specified some ways above to implement the variable-length array in C and alternative ways of the variable-length array. These might be handy when interacting with the variable-length arrays in C .
About the author
<img alt="" data-lazy-src="https://secure.gravatar.com/avatar/d014e3711df41253029f4d4199698df8?s=112&r=g" data-lazy- height="112" src="data:image/svg xml,” width=”112″>
Kalsoom Bibi
Hello, I am a freelance writer and usually write for Linux and other technology related content
