Proper way to accomplish this construction using constructor chaining?

Question

I have an assignment for my first OOP class, and I understand all of it including the following statement:

You should create a class called ComplexNumber. This class will contain the real and imaginary parts of the complex number in private data members defined as doubles. Your class should contain a constructor that allows the data members of the imaginary number to be specified as parameters of the constructor. A default (non-parameterized) constructor should initialize the data members to 0.0.

Of course I know how to create these constructors without chaining them together, and the assignment does not require chaining them, but I want to as I just like to.

Without chaining them together, my constructors look like this:

class ComplexNumber
{
    private double realPart;
    private double complexPart;

    public ComplexNumber()
    {
         realPart = 0.0;
         complexPart = 0.0
    }

    public ComplexNumber(double r, double c)
    {
         realPart = r;
         complexPart = c;
    }
    // the rest of my class code...
}

Answer 1

Is this what you're looking for?

public ComplexNumber()
    : this(0.0, 0.0)
{
}

public ComplexNumber(double r, double c)
{
     realPart = r;
     complexPart = c;
}

Answer 2

@Rex has the connect answer for chaining.

However in this case chaining or any initialization is not necessary. The CLR will initialize fields to their default value during object constructor. For doubles this will cause them to be initialized to 0.0. So the assignment in the default constructor case is not strictly necessary.

Some people prefer to explicitly initialize their fields for documentation or readability though.

Answer 3

I am still trying to grasp the concept of constructor-chaining, so it works, but why/how?

The 'how' of constructor chaining by using the 'this' keyword in the constructor definition, and shown in Rex M's example.

The 'why' of constructor chaining is to reuse the implementation of a constructor. If the implementation (body) of the 2nd constructor were long and complicated, then you'd want to reuse it (i.e. chain to it or invoke it) instead of copy-and-pasting it into other constructors. An alternative might be to put that code, which is shared between several constructors, into a common subroutine which is invoked from several constructors: however, this subroutine wouldn't be allowed to initialize readonly fields (which can only be initialized from a constructor and not from a subroutine), so constructor chaining is a work-around for that.