C# Variable Initialization Question

Question

Good Day,

Is there any difference on whether I initialize an integer variable like:

int i = 0;
int i;

Does the compiler or CLR treat this as the same thing? IIRC, I think they're both treated as the same thing, but I can't seem to find the article.

coson

Answer 1

Yes, it pretty much is the same thing.

You can refer to this article on Coding Horror

Answer 2

As the following link states, they are exactly the same:

http://msdn.microsoft.com/en-us/library/aa664742%28VS.71%29.aspx

Answer 3

If the variable i is an instance variable, it will be assigned the value 0 automatically. If it is a local variable in a method, it is undefined, so you would need to assign it a value before using it.

For example:

class Program
{
    static void Main(string[] args)
    {
        intTest it;

        it = new intTest();

        Console.ReadLine();
    }

    class intTest
    {
        int i;

        public intTest()
        {
            int i2;

            Console.WriteLine("i = " + i);
            Console.WriteLine("i2 = " + i2);
        }
    }
}

The above will not compile because i2 is unassigned. However, by assigning 0 to i2, i.e.

int i2 = 0;

and compiling, then running, will show that both are now assigned 0.

Answer 4

Any time you create a type in C#, it automatically gets filled in with padded zeros. In the case of a class (reference type), this equates to a null pointer. So, technically, any time you're working with classes, the following are identical:

MyClass class;
MyClass class2 = null;

With value types (any struct, including int/float/double/etc), the type is passed with zeros, so the following are equivalent:

int i;
int j = 0;

However, in a method, the compiler checks to see if you've assigned a value to your types prior to using it. If you do the following, the compiler will complain:

int i;
Console.WriteLine{"{0}",i);

Technically, the above should be fine - but since it's a common source of programmer error, the compiler specifically checks for unassigned local variables, and complains. However, this is a compile-time complaint, and not a CLR issue. You can make IL that does the above, and it runs fine.

Answer 5

I looked at the IL (using ildasm) and its true that only the int set to 0 is really set to 0 in the constructor.

public class Class1
{
    int setToZero = 0;
    int notSet;
}

Generates:

.method public hidebysig specialname rtspecialname 
        instance void  .ctor() cil managed
{
  // Code size       15 (0xf)
  .maxstack  8
  IL_0000:  ldarg.0
  IL_0001:  ldc.i4.0
  IL_0002:  stfld      int32 ClassLibrary1.Class1::setToZero
  IL_0007:  ldarg.0
  IL_0008:  call       instance void [mscorlib]System.Object::.ctor()
  IL_000d:  nop
  IL_000e:  ret
} // end of method Class1::.ctor

Answer 6

These are only equivalent for fields (class variables). Fields are automatically assigned the default values when the class is initialized. Within a method or property, the unassigned variable remains unassigned and will cause a compiler error if you try to access it's value.

Answer 7

With all this talk, it is worth mentioning the "default" keyword in C#.

I.e. int i; is equivalent to int i = default(int); which is equivalent to int i = 0; and MyClass o = default(MyClass); is equivalent to MyClass o = null;

This is especially relevant when using linq methods such as .SingleOrDefault() because you can always use the following to make your code more readable:

int someValue = collection.<various linq methods>.SingleOrDefault();
if (someValue == default(int))
{
  //Code for the default case
}

and

MyClass someValue = collection.<various linq methods>.SingleOrDefault();
if (someValue == default(MyClass))
{
  //Code for the default case
}