Most typical use of a private constructor is hiding of a default parameterless constructor. For example:
public class Owner {}
public class NotDirectlyInstantiatingObject {
public static NotDirectlyInstantiatingObject Create(Onwer owner) {}
private NotDirectlyInstantiatingObject() { }
}
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