0

In the following code if I declare the variable-length array 'int array1[x]' before scanning the desired length of the array 'x', I receive ' segmentation fault (core dumped)' while execution. (compilation is error-free). I used strictly ANSI C99 standards by using option -std=c99 while compiling.

My question is Why can't I club all the declarations together?

// code to find a minimum value in a variable-length array
#include<stdio.h>

int minval(int [], int); 

int main(void)
{
    int x, i;

    int minivalue;

    printf("Enter the total number of array elements you wish to define?");
    scanf("%i",&x);

    int array1[x];          

    printf("Enter the elements now:");
    for (i = 0; i < x; i++)
        scanf("%i",&array1[i]);

    minivalue = minval(array1, x);

    printf("\nMinimum value in the array is = %i\n",minivalue);

    return 0;
}

int minval(int array2[], int x)     
{
    int i;
    int minivalue;

    minivalue = array2[0];

    for (i=0; i < x; i++){
        if (minivalue > array2[i])
            minivalue = array2[i];  
    }

    return (minivalue);
}
Improve this question
7
  • That's not valid C. I'm actually surprised it even compiles. You'll need to use dynamic memory allocation (in other words malloc). Commented Apr 24, 2012 at 8:44
  • it compiles and runs properly. I used -std=c99 option too for compiling. Commented Apr 24, 2012 at 8:50
  • It's either a GCC extension then, or a special case in the standard (I suspect a GCC extension). Commented Apr 24, 2012 at 8:51
  • @Corbin but why it is not valid. standard says a variable can be declared anywhere in the program as long as the declaration occurs before the variable is first used. Commented Apr 24, 2012 at 9:01
  • Because you can't declare an array with a variable like that. int a[x] is not considered valid. That's because it depends on a dynamic allocation. That's because x's value is not known at compile time. If the value of x is known at compile time, it is valid. I suspect that what is happening when you place it after is that a GCC extension is automatically converting it to Emanuele Bezzi's answer. When it's placed before, GCC is doing the same, except x1 is not initialized and therefore the malloc has the potential to go horribly wrong. Commented Apr 24, 2012 at 9:04

3 Answers 3

Reset to default
6

In the following code if I declare the variable-length array 'int array1[x]' before scanning the desired length of the array 'x', I receive ' segmentation fault (core dumped)' while execution.

You cannot declare a variable length array with an uninitialized value.

When you move the int array1[x] before the scanf() the x does not have a valid value.

Improve this answer
Sign up to request clarification or add additional context in comments.

4 Comments

but x is actually initialised when the program is run. so how does it matter for the compiler if x is initialised or not while compilation? I am not able to understand why compiler behaves differently if nothing else except the location of the array declaration is changed?
No, x is not initialized. To be initialized you'd have to have int x = 42;. With the plain int x; you're only defining x.
Now my question is how does it matter to compiler if an array is declared before or after the scanning statement? remember the variable, this array uses is already declared!..
declaration is not definition. A declaration (int x;) tells the compiler the name being declared is an object of a certain type; a definition (int x = 42;) tells the compiler the same as a declaration and the object value. In your problem code the object named x is declared, not initialized ... its value is garbage until it gets assigned a value (at the scanf() call).
0

@Saurabh: try playing "computer" at runtime in the C99 standard. you come across the declaration int x. it has some large garbage value. then you read the array declartion with the large value - you try to allocate that - run out of stack memory - you seg fault. instead if you read a value for x first that is reasonable in size and then the array allocation, you are able to allocate the memory on the stack. regardless, this c99 feature is bad. use std::vector instead.

Improve this answer

Comments

-1

Replace

int array1[x];

with 

int* array1 = (int*) malloc (x * sizeof int);

so you allocate enough memory to have x elements contained in array1.

Do not forget to free the memory after, by adding

free(array1)

at the end of your program.

Improve this answer

2 Comments

-1. This would not solve his problem. Variable length arrays are valid C99. What is currently happening when he moves the statement up is that x is uninitialised. The segfault is probably caused by the value being too big and the stack overflowing. If he moved the statement but used malloc as you suggest, it just hides the problem. In cases where x holds a value >= the allocation might succeed but you are still relying on undefined behaviour.
X is initialized only during runtime. isn't it? then how does shifting the array declaration below the scanning statement helps the code run? thats my question..

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.