Help with a functions using arrays/if statements

[napalmgrenade]

Hi all, basically my assignment is to write a program to alter the salaries of n employees based on the following conditions: If the salary is less than 10,000 then give a 5% bonus etc. If its 10,000-20,000 then another set of changes to the salary are done, anything higher than 20,000 also receives its own changes.

As you can see, the size of the arrays that contain the values for salary and new salary are dependent on integer n, which is entered by the user. This format does not work on my compiler, as the program itself stops before printing the first line. However when I change s[n] to s[100], l[n] to l[100], the function works. I want to know why I cannot use the s[n] format, instead of just using a random number for the number of salaries/altered salaries after changes. Any help would be greatly appreciated, thank you.

#include <stdio.h>
#include <stdlib.h>


int main()
{
    int i,n;
    float s[n],l[n];
    printf("Please enter the number of employees: ");
    scanf("%d",&n);
    for (i=0;i<n;i++)
    printf("Please enter the salary: ");
    scanf("%f",&s[i]);
    if (s[i]<10,000)
    {
        l[i]=s[n]+(0.05*s[i]);
        printf("Salary after changes: %f",l[i]);
    }
    else if ((s[n]>=10,000)&&(s[n]<20,000))
    {
        l[i]=s[i]-(0.03*s[i]);
        l[i]=l[i]-(0.01*l[i]);
        l[i]=l[i]+(.025*l[i]);
        printf("Salary after changes: %f",l[i]);
    }
    else
    {
        l[i]=s[i]-(0.05*s[i]);
        l[i]=l[i]-(0.02*l[i]);
        l[i]=l[i]-(0.01*l[i]);
        l[i]=l[i]+(0.08*l[i]);
        printf("Salary after changes: %f",l[i]);
    }
    return 0;
}

[Salem]

> float s[n],l[n];
> printf("Please enter the number of employees: ");
> scanf("%d",&n);
C doesn't predict the future, or revise the past.
You need to input n BEFORE creating an array.

> if (s[i]<10,000)
Beware of the comma operator,
This isn't what you think it is.

[grumpy]

n is an uninitialised variable. Formally, according to the C standard, accessing its value yields undefined behaviour.

Your usage does not create an array that will magically resize itself when n is changed. It attempts to access an indeterminate value (an operation that, in itself may fail) and then create an array who's size is that value.

Assuming your compiler is compliant with the 1999 C standard, initialise n to a valid value (for example, by reading its vale using scanf()) BEFORE defining "float s[n], l[n];" If your compiler is compliant with an older C standard (say the 1989 standard) your usage is invalid, and will yield a compile time error, since arrays can only be created with a size known to the compiler (i.e. not based on data obtained at run time).

Incidentally, the test "if (s[i] < 10,000)" compares s[i] with the value 10, not 10000. When programming C or C++ the comma operator is not used in constants like that. The condition will therefore always test false (s[i] < 10 is evaluated, the comma operator causes that to be discarded, and the result of the test is zero (000)).

[jwroblewski44]

dynamic allocation would be something you could use/research. ie malloc in C, new in C++. dont forget to free after!

and when getting input from user, by warey of newlines ('\n') left in the input stream