Use of Constructors - Odd Doubt

Question

I'm reading about constructors,

When an object is instantiated for a class, c'tors (if explicitly written or a default one) are the starting points for execution. My doubts are

• is a c'tor more like the main() in C
• Yes i understand the point that you can set all the default values using c'tor. I can also emulate the behavior by writing a custom method. Then why a c'tor?

Example:

//The code below is written in C#.
public class Manipulate
    {
        public static int Main(string[] args) {
            Provide provide = new Provide();
            provide.Number(8);
            provide.Square();
            Console.ReadKey();
            return 0;
        }
    }   

 public class Provide {
        uint num;
        public void Number(uint number)
        {
            num = number;
        }
        public void Square()
        {
            num *= num;
            Console.WriteLine("{0}", num);
        }
    }

Am learning to program independently, so I'm depending on programming communities, can you also suggest me a good OOP's resource to get a better understanding. If am off topic please excuse me.

Answer 1

Head First OOA&D will be a good start.

Dont you feel calling a function for setting each and every member variable of your class is a bit overhead.

With a constructor you can initialize all your member variables at one go. Isnt this reason enough for you to have constructors.

Answer 2

Generally you should do all your initialization in the constructor. The constructor is the first thing called when an instance of your class is created, so you should setup any defaults here.

Answer 3

Constructor and Destructor functionality may be emulated using regular methods. However, what makes those two type of methods unique is that the language treats them in a special way.

They are automatically called when an object is created or destroyed. This presents a uniform means to handle the most delicate operations that must take place during those two critical periods of an object's lifetime. It takes out the possibility of an end user of a class forgetting to call those at the appropriate times.

Furthermore, advanced OO features such as inheritance require that uniformity to even work.

Answer 4

First of all, most answers will depend at least a bit on the language you're using. Reasons that make great sense in one language don't necessarily have direct analogs in other languages. Just for example, in C++ there are quite a few situations where temporary objects are created automatically. The ctor is invoked as part of that process, but for most practical purposes it's impossible to explicitly invoke other member functions in the process. That doesn't necessarily apply to other OO languages though -- some won't create temporary objects implicitly at all.

Answer 5

I think a good way to learn is comparing OOP between languages, it's like seeing the same picture from diferent angles.

Googling a while:

• java (I prefer this, it's simple and full)- http://java.sun.com/docs/books/tutorial/java/concepts/
• python - http://www.devshed.com/c/a/Python/Object-Oriented-Programming-With-Python-part-1/
• c# - http://cplus.about.com/od/learnc/ss/csharpclasses.htm

Why constructors? The main diference between a simple function (that also could have functions inside) and an Object, is the way that an Object can be hosted inside a "variable", with all it functions inside, and that also can react completly diferent to an other "variable" with the same kind of "object" inside. The way to make them have the same structure with diferent behaviours depends on the arguments you gave to the class. So here's a lazy example:

car() is now a class.

c1 = car()

c2 = car()

¿c1 is exactly c2? Yes.

c1 = car(volkswagen)

c2 = car(lamborghini)

C1 has the same functionalities than C2, but they are completly diferent kinds of car() Variables volkswagen and lamborghini were passed directly to the constructor. Why a -constructor-? why not any other function? The answer is: order.

That's my best shot, man, for this late hours. I hope i've helped somehow.

Answer 6

You can't emulate the constructor in a custom method as the custom method is not called when the object is created. Only the constructor is called. Well, of course you can then call your custom method after you create the object, but this is not convention and other people using your object will not know to do this.

A constructor is just a convention that is agreed upon as a way to setup your object once it is created.

Answer 7

One of the reasons we need constructor is 'encapsulation',the code do something initialization must invisible

Answer 8

You also can't force the passing of variables without using a constructor. If you only want to instantiate an object if you have say an int to pass to it, you can set the default constructor as private, and make your constructor take an int. This way, it's impossible to create an object of that class without having it take an int.

Answer 9

Sub-objects will be initialized in the constructor. In languages like C++, where sub-objects exist within the containing object (instead of as separate objects connected via pointers or handles), the constructor is your only chance to pass parameters to sub-object constructors. Even in Java and C#, any base class is directly contained, so parameters to its constructor must be provided by your constructor.

Lastly, any constant (or in C#, readonly) member variables can only be set from the constructor. Even helper functions called from the constructor are unable to change them.