初始化变量

Question

Is it better to declare and initialize the variable or just declare it? What's the best and the most efficient way?

For example, I have this code:

#include <stdio.h>

int main()
{
    int number = 0;

    printf("Enter with a number: ");
    scanf("%d", &number);

    if(number < 0)
        number= -number;

    printf("The modulo is: %d\n", number);

    return 0;
}

If I don't initialize number , the code works fine, but I want to know, is it faster, better, more efficient? Is it good to initialize the variable?

Answer 1

scanf can fail, in which case nothing is written to number . So if you want your code to be correct you need to initialize it (or check the return value of scanf ).

The speed of incorrect code is usually irrelevant, but for you example code if there is a difference in speed at all then I doubt you would ever be able to measure it. Setting an int to 0 is much faster than I/O.

Answer 2

Suppose if you don't initialize a variable and your code is buggy.(eg you forgot to read number). Then uninitialized value of number is garbage and different run will output(or behave) different results.

But If you initialize all of your variables then it will produce constant result. An easy to trace error.

Yes, initialize steps will add extra steps in your code at low level. for example mov $0, 28(%esp) in your code at low level. But its one time task. doesn't kill your code efficiency.

So, always using initialization is a good practice !

Answer 3

Don't attribute speed to language; That attribute belongs to implementations of language. There are fast implementations and slow implementations. There are optimisations assosciated with fast implementations; A compiler that produces well-optimised machine code would optimise the initialisation away if it can deduce that it doesn't need the initialisation.

In this case, it actually does need the initialisation. Consider if scanf were to fail. When scanf fails, it's return value reflects this failure. It'll either return:

1. A value less than zero if there was a read error or EOF (which can be triggered in an implementation-defined way, typically CTRL+Z on Windows and CTRL+d on Linux),
2. A number less than the number of objects provided to scanf (since you've provided only one object, this failure return value would be 0) when a conversion failure occurs (for example, entering 'a' on stdin when you've told scanf to convert sequences of '0'..'9' into an integer),
3. The number of objects scanf managed to assign to. This is 1, in your case.

Since you aren't checking for any of these return values (particular #3), your compiler can't deduce that the initialisation is necessary and hence, can't optimise it away. When the variable is uninitialised, failure to check these return values results in undefined behaviour. A chicken might appear to be living, even when it is missing its head. It would be best to check the return value of scanf. That way, when your variable is uninitialised you can avoid using an uninitialised value, and when it isn't your compiler can optimise away the initialisations, presuming you handle erroneous return values by producing error messages rather than using the variable.

edit: On that topic of undefined behaviour, consider what happens in this code:

if(number < 0)
    number= -number;

If number is -32768, and INT_MAX is 32767, then section 6.5, paragraph 5 of the C standard applies because -(-32768) isn't representable as an int.

Section 6.5, paragraph 5 says:

If an exceptional condition occurs during the evaluation of an expression (that is, if the result is not mathematically defined or not in the range of representable values for its type), the behavior is undefined.

Answer 4

With modern compilers, there isn't going to be any difference in efficiency. Coding style is the main consideration. In general, your code is more self-explanatory and less likely to have mistakes if you initialize all variables upon declaring them. In the case you gave, though, since the variable is effectively initialized by the scanf, I'd consider it better not to have a redundant initialization.

Answer 5

Before, you need to answer to this questions:

1) how many time is called this function? if you call 10.000.000 times, so, it's a good idea to have the best.

2) If I don't inizialize my variable, I'm sure that my code is safe and not throw any exception?

After, an int inizialization doesn't change so much in your code, but a string inizialization yes.

Be sure that you do all the controls, because if you have a not-inizialized variable your program is potentially buggy.

Answer 6

I can't tell you how many times I've seen simple errors because a programmer doesn't initialize a variable. Just two days ago there was another question on SO where the end result of the issue being faced was simply that the OP didn't initialize a variable and thus there were problems.

When you talk about "speed" and "efficiency" don't simply consider how much faster the code might compile or run (and in this case it's pretty much irrelevant anyway) but consider your debugging time when there's a simple mistake in the code do to the fact you didn't initialize a variable that very easily could have been.

Note also, my experience is when coding for larger corporations they will run your code through tools like coverity or klocwork which will ding you for uninitialized variables because they present a security risk.

Answer 7

you're using scanf when the variable already has got a value. this might not work with all types of compiler. hence if you want take a value from the user,don't initialize it.