The difference between declaring something and making it equal to a new?

Benjamin Ashton

I am quite new to C# and am moving over from a mediocre knowledge of Pascal, so theres quite a bit new construct to learn. There is probably 2 very simple answers to my questions, but I have done some research and have not found any explanation I can relate too, so I would be grateful if someone could help me out.

First Question
What is the difference between declaring something with just its type and declaring it as well as making it equal to a "new" of the same type?

//Simple declaration
Int myInteger;
Random myRand;
//Making it equal to the same type
Int myInteger = new Integer();
Random myRand = new Random();

Second Question
I am fully trying to understand how Static works, but struggling and just end up making everything static because you need static variables inside your static main and so on. I know its something to do with only running the program once, but would really need a simple and clear explanation of it before I can move on to fully understanding the complications of it, maybe a with a metaphor would help.

Thanks for the help, and I look forward to replies!

7 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes14y ago
Accepted answer
On the first point, there's no difference between this:

Random myRand;
myRand = new Random();

and this:

Random myRand = new Random();

The latter is really just short-hand for the former.

Notice that for basic types such as int, you don't need to use 'new' at all. This line:

int myInteger = new int();

is just the same as this:

int myInteger = 0;

You only need to declare a member static if it applies to the class as a whole rather than a specific instance of it. It follows that you don't need an instance variable to access a static member, you just use the class name.

Notice in particular that the Main() method must always be static. If it were not, then you'd need to create an instance of the class in which it's placed to access it and so it wouldn't be the first method to be executed when the application begins.
0
Deepak Goyal14y ago
Really nice explain
0
Benjamin Ashton14y ago
Wow thanks, that fully makes sense now. Thanks again!
0
Vulpes14y ago
An instance is just another word for an object.

A class is just a blueprint for creating objects (or instances) of a particular type.

This simple program may help you to understand static members better. Here MyClass has a static field, counter, which counts how many instances of that class have been created. Each time the constructor is called 'counter' is incremented by one:

using System;

class MyClass
{
static int counter;

public static int Counter
{
get { return counter; }
}

public MyClass()
{
counter++;
}
}

class Test
{
static void Main()
{
MyClass mc = new MyClass();
MyClass mc2 = new MyClass();
Console.WriteLine(MyClass.Counter); // 2
Console.ReadKey();
}
}

Now, if counter were an instance (i.e. non-static) field, then the program wouldn't work. Each instance of MyClass would then have its own copy of counter which would always end up with a value of 1 as it would know nothing about what (if any) other instances have been created.

When you have a static field, you only have the one copy which is stored separately from objects of the same class. A static field retains its value throughout the duration of the program regardless of how many instances of the class have been created (and, in some cases, destroyed) in the meantime.
0
Benjamin Ashton14y ago
Thanks! I fully understand the first question now, but am still a bit iffy on the second one. Could you define the use of the word Instance please?
0
Vulpes14y ago
If you just have this:

Random myRand;

then it declares a variable myRand to be of type Random.

However, nothing has been assigned to this variable and so it doesn't actually refer to a Random object or even to no object (null).

This expression:

new Random();

creates an object of type Random by allocating memory for it in an area of memory known as 'the heap' and then calling its constructor. The expression then returns a reference (or pointer) to where this object is stored on the heap.

So, if you now combine the two:

Random rand = new Random();

the variable rand now points to a newly created Random object (or an 'instance' of Random as it's sometimes called).

We can now call an instance method on that object using the rand variable. For example:

int number = rand.Next(10); // gets a random number between 0 and 9

The Random class doesn't have any static members, but suppose it did have one called StaticMethod which took no parameters and had no return value. You would then call this static method as follows:

Random.StaticMethod(); // use the class name to access a static member

It would be a mistake to access it like this because static members do not know anything about instances of the same class:

rand.StaticMethod(); // not allowed because rand refers to an instance of Random

Any clearer?
0
Benjamin Ashton14y ago
Thanks for the reply, and I am grateful but I am still having problems understanding them both fully. Why can't you just use just use "Random myRand;" why must you declare it as a =new Random(); I don't really understand your explanation of static, although I am sure it is a perfectly acceptable one, I just don't get all this instance stuff. Sorry for not understanding!
0