what are the real world example- use of private constructor and constructor overloading

Most typical use of a private constructor is hiding of a default parameterless constructor. For example:

public class Owner {/* ... */}

public class NotDirectlyInstantiatingObject {
    // let's say, we want to have only one method of instantiating of this class by the user,
    // to guarantee that each instance is added to some owner:
    public static NotDirectlyInstantiatingObject Create(Onwer owner) {/* ... */}
    // to prevent direct instantiation of this class, we need to disable the default constructor; here is how:
    private NotDirectlyInstantiatingObject() { } // it exists but cannot be called
}

There are very many designs of the code where the direct instantiation of the class is hidden from a user, different in the ways of public instantiations of such class, but the way of disabling of the parameterless default constructor is always the same.

For understanding the rules for default constructors, please read about it: http://msdn.microsoft.com/en-us/library/aa645608%28v=vs.71%29.aspx[^].

As to "constructor overloading", this is just the useless term. I would never use the confusing term "overloading" even for other methods, because nothing is really "loaded". Let's see. It actually simply means that the syntax allows to create different (formally unrelated) methods with the same name. A compiler recognizes them at the point of the call by actual parameters, and only if such determination is ambiguous, it generates the compilation error. Now, let's see: in C#, all constructors of the same class has the same name as the name of this class. It means that there are no "overloaded" or "non-overloaded" constructors; if you will, the are all "overloaded". So your question is reduced to the question: "what are the real world examples of using different constructors". Come on, such question would be ridiculous. Too many reasons; even for simple convenience of the class user…

I hope I answered both questions: provided some example of the use of the private constructor and explained why there is no a need to give example on those almost mythical "overloaded constructors". Also, please follow my advice you can find in my comment to the question.

—SA

An Intro to Constructors in C#[^]

Private constructor - a classic real world example is the Singleton pattern - Singleton pattern[^].
There are tons of examples of this implementation available in different programming languages.

Constructor overloading - if you create a shape class and then subclass circle and rectangle - you will have two constructors, one passing in radius and one passing in height and width.