NP143 struct

Excellent explanation. Thank you very much for help.

You're roughly right though the following is a more accurate description of what 'new' does (and the order in which it does it) when used with a constructor of a reference type (Foo let's say).

1. It allocates sufficient memory on the heap to store the instance fields of Foo plus a further 8 bytes overhead (on a 32 bit system).

2. It initializes the overhead (don't worry about what this entails).

3. It sets all the bytes used to store the fields to 0 (the zero byte). This means that all the fields are initially set to their default values (null for a reference type, zero for numeric types, false for bool, '\0' for char etc.)

4. If any of the fields have initial values assigned to them (for example private int i = 3;), it sets the fields to those values.

5. It then calls Foo's constructor which calls its parent's constructor and so on all the way up to System.Object's constructor. The code in these constructors is then executed as the stack unwinds finishing with the code in Foo's constructor.

6. It returns a reference to the newly created object.

In practice, you seldom need to remember all this. All you need to know is that 'new' causes a new Foo object to be created and returns a reference to it.

Moving on to your second point, you only need to use code of this pattern:

SomeType someVariable = new SomeType(); // or whatever

if  someVariable hasn't been declared before. This might be the case if someVariable were a local variable or if it were a field which you were initializing where it's declared, rather than using a separate assignment statement.

The following statement doesn't fall into this pattern and is therefore invalid syntax:

    Shoe Bill.LeftShoe = new Shoe();

because the LeftShow field has been declared before within the Dude class as being of type Shoe and Bill is a reference to a Dude object which has  already been created.

However, there's nothing wrong with a simple assignment statement such as this:

Bill.LeftShoe = new Shoe();

So when we declare Employee myAssistant = new Employee(); in which new Employee() is doing following 3 jobs:

1)    It creates an Employee object which is myAssistant

2)    It allocates the needed memory to hold myAssistant

3)    It constructs Employee constructor method

I wish to know whether my understanding is correct.

Also please explain why it is not correct to say so.

Shoe Bill.LeftShoe = new Shoe();

A book is explaining about Declaring Objects.

Employee myAssistant = new Employee();.

There is a sentence:

“The last portion of the statement, Employee() is the name of a method that constructs an Employee object”. Employee() is a constructor method.

I can understand the meaning of the “Employee() is a constructor method”. What is meant by “constructs an Employee object” (highlighted in yellow)?

Because if you have this line:

    Bill.LeftShoe = new Shoe();

you're assigning a new Shoe object to the field  Bill.LeftShoe.

This is the same as:

    Shoe shoe = new Shoe();

    Bill.LeftShoe = shoe;

If Bill.LeftShoe were on the RHS i.e:

    shoe = Bill.LeftShoe;

then you'd be assigning what's in Bill.LeftShoe (currently null) to the Shoe variable, shoe.

Please explain the reason why Bill.LeftShoe must come in the LHS.   

Not quite, but it can be written like this:

Shoe shoe = new Shoe();

Bill.LeftShoe = shoe;

That means code Bill.LeftShoe = new Shoe(); can be written as follows:

Shoe shoe = new Shoe();

shoe = Bill.LeftShoe;

You've explained it yourself, Maha, with your last paragraph:

"For example if we say Shoe shoe = new Shoe(); new sets aside enough memory to hold shoe. Whereas Shoe() is the name of a method that constructs an Shoe object."  

The only thing I'd add is that the method is, of course, the Shoe constructor and once the object has been constructed a reference to it is then assigned to the field Bill.LeftShoe.

Thank you very much for explanation.

Bill.LeftShoe = new Shoe();

Above code is confusing me. Bill is an instance of Dude and LeftShoe is a field of a Dude class. Bill.LeftShoe is giving new Shoe instances. Is there anything to explain please explain the meaning of it?

If you change the program back to how it was originally and make Shoe a class rather than a struct, then you will need to change the Dude.CopyDude() method to the following in order for the program to give the same output as before:

    public Dude CopyDude()
    {
        Dude newPerson = new Dude();
        newPerson.Name = Name;
        newPerson.LeftShoe = new Shoe();
        newPerson.LeftShoe.Color = LeftShoe.Color;
        newPerson.RightShoe = new Shoe();
        newPerson.RightShoe.Color = RightShoe.Color;
        return newPerson;
    }

It's no longer enough to set newPerson.LeftShoe to the current object's LeftShoe property  If you do that then both properties will point to the same Shoe object and so changing the color of newPerson's LeftShoe will automatically change the color of the current object's LeftShoe - and both LeftShoes will end up red!

A similar argument applies to the RightShoe property.

You therefore have to create new Shoe objects and set the Color properties individually.

This doesn't happen when Shoe is a struct because it's the value of the struct that's copied (i.e. the value of the Color string) not a reference to where the Shoe object resides on the heap.

If we change into class instead of struct (highlighted in red) what are the changes must be done in the program in order to execute it to give following output? Please explain the changes.

Bill: Dude!, I have a Blue shoe on my right foot, and a Blue on my left foot

Ted: Dude!, I have a Red shoe on my right foot, and a Red on my left foot

In that case, you're just creating a new Dude object in the usual way (i.e. using 'new' rather than a 'Copy' method) and then setting its properties.

As you're still setting all the properties manually (previously they were all reset after being copied from Bill),  the output is the same as before.

I think the purpose of this program was just to show how you might go about cloning an object. I don't think there's any deeper significance than that.

I am sorry I have forgotten to mention. While removing the code highlighted in blue you have to comment out Dude Ted = Bill.CopyDude(); as well. Under this circumstances program is executing well.