I am a novice eat programming. I have some confusion of the real value of constructors of classes in C++. Basically what is the real practical use of having a constructor over a member function?

I know that constructors are useful in initiation of the date member of a class and if the data members are not initialized then they can have garbage values and result in strange things. If that is the purpose of Constructors over the member functions then are we to have equal number of constructors as the member functions so as to initialize all data members found in a class? We need that much of constructors as the member functions if we are to initialize all the data members by constructors.

Why cannot the normal member functions do the same task? What is the difference of data members being initialized by constructors and member functions? I find it difficult to see the difference. Can anyone help in enlightening me as I am sure I am missing something?

Thanks
Shri

There really isn't a difference in my opinion. Short of having easier code and objects initialized with their respective data when you create them, functions can do the same thing, but why call an extra function to set a Cat object's age when you could just do Cat(5) or something similar.

Not sure if I totally understand your question. My reply is just a reply to what I think the question was.

if (everyone_would_write_proper_English)
	Make_skater_00_reread_text_50_times = false;

Classes don't need multiple constructors/destructors actually. One constructor/destructor per class can do the job. It is possible though to have more than one constructor/destructor.

In most cases, every class has its own private members that are initialized in the class constructor. These members are declared privately because you are most likely going to use them more than once and in multiple functions. Those are the global variables.

There are also variables that can be initialized (and declared) in a function itself, so not declared privately or initialized in the constructor initialization list. This is done because these members are only used once or so in a function in the whole application. Those are the local variables.

Why would programmers make a variable global if they only use it once? Or why would programmers declare the same variable (with same objective) 5 times in different functions when you can declare it globally and once?

Constructors: Initializing globally declared members.
Functions: Initializing (and declaring) local members.

That's the only difference I can think of. Hope this helped clarifying what you needed. If it didn't, explain your question better.

You can, and it's often recommended in a sense... In cases where one has multiple constructors, it is often easier to create an initialization method, which can be called from each constructor, which reduces code repetition. However, for members variables that are of class-types, one has to use a constructor to initialize them as well:

class Tail
{
    public:
    enum TailType { Short, Long };
    Tail(TailType t) { .... }
};

class Cat
{
     public:
     Cat() : tail(Tail::Short)
     {
           // Do nothing
     }
     private:
     Tail tail;
};

You can't call tail's constructor explicitly (at least in an obvious way) outside of a constructor.

There are a few properties of constructors that make them rather desirable:

1.) Constructors are automatically called when they need to be. One needs not rely on one's tendency to remember to do something, which is almost always a good thing.

2.) Explicitly defined copy-constructors for classes that require deep copying (i.e. those that hold on to pointers or sometimes in the case of handles) usually makes life easier for the programmer. Instead of having to duplicate by calling a method, or passing by reference (which at times is not desireable), a copy-constructor (a specialized method that the compiler recognizes) is called to actually do the work.

For example, I have class X { public: int* y; };

X v1;
v1.y = new int;
X v2;
// This copies the pointer value, not the value pointed to by member X::y
v1 = v2;

3.) RAII (resource acquisition is initialization) isn't nearly as foolproof without them. Don't worry if you've never seen this terminology... it tends to come later for most.

Overloading constructors is good if you need to initialize with varying amounts of detail per object.