Notes on constructor and destructor C++




Notes on constructor and destructor C++


The following texts are the property of their respective authors and we thank them for giving us the opportunity to share for free to students, teachers and users of the Web their texts will used only for illustrative educational and scientific purposes only.


All the information in our site are given for nonprofit educational purposes

The information of medicine and health contained in the site are of a general nature and purpose which is purely informative and for this reason may not replace in any case, the council of a doctor or a qualified entity legally to the profession.



Notes on constructor and destructor C++



Constructor: A member function with the same name as its class is called Constructor and it is used to initialize the objects of that class type with a legal initial value. If a class has a constructor, each object of that class will

be initialized before any use is made of the object. Need for Constructors: A variable, an array or a structure in

C++ can be initialized at the time of their declaration.

Eg: int a[3]= {5,10,15};                     struct student

{ int rno;

float m1,m2,m3; };

student s1={1,55.0,90.5,80.0};

But this type of initialization does not work for a class because the class members have their associated access specifiers. They might not be available to the outside world (outside their class). A Constructor is used to initialize the objects of the class being created (automatically called by the compiler).

Difference between a constructor and an ordinary member function:




Member Function


Name of the Class

Any Valid Identifier


Initialize the object when it is being created

For any general purpose




Return type

Should not keep

Must be there at least void


Declaration and Definition: A constructor is a member function of a class with the same name as that of its class

name. A constructor is defined like other member functions of a class. It can be defined either inside the class definition or outside the class definition.


Eg: class X        //Inside the Class   

{ int i;


X ( ) //Constructor defined inside

{          i = 0;}};

This simple constructor (X::X ( ) ) is as an inline member function.


{int i ;


X ( ); //Only constructor declaration.}; //CLASS ENDS

X :: X ( ) //Constructor defined outside

{i = 0;}


Generally constructor will be defined under public section, which can be available to non members also. But it can also be defined under private or protected. A private or protected constructor is not available to the non-member functions. I.e. With a private or protected constructor, you cannot create an object of the same class in a non-member function. Invocation : Constructors are invoked in order of creation and destroyed in the reverse order of creation.

There are three types of constructors

a) Non-parameterized or Default Constructor     b) Parameterized Constructor        c) Copy Constructors

a) Default constructor: A constructor that accepts no parameter is called the default constructor. With a default constructor, objects are created just the same way as variables of other data types are created.

If a class has no explicit constructor defined, the compiler will supply a default constructor. This implicitly declared default constructor is an inline public members of its class. Declaring a constructor with arguments hides the default constructor. There can be a default constructor as well as another constructor with arguments for a class, having multiple constructors is called as constructor overloading. A constructor can also have default arguments. A constructor with default arguments is equivalent to a default constructor.

Eg: class Rectangle

{          float l,b,a;

public:             Rectangle ( float len = 5.0, float bre = 5.0)   //Constructor with Default arguments

{l = len;           b = bre;}};

The default constructors are very useful when you want to create objects without having to type the initial objects every time with pre specified initial values or if you want to create array of objects of your class type. You can’t create an array of objects unless your class has a default constructor (implicitly or explicitly defined).

b) Parameterized Constructor: A constructor that take arguments, is called as parameterized constructor. The parameterized constructor allow us to initialize the various data elements of different objects with different values when they are created. This is achieved by passing different values as arguments to the constructor function when the objects are created.

Eg:   Rectangle ( float len , float bre )                       //Parameterized Constructor.

{          l = len; b = bre;}

With a parameterized constructor, the initial values must be           passed at the time of object created. This can be done in two    manners:

(i)By calling the constructor implicitly (implicit call) Eg:    Rectangle first(8.5,3.9);

(ii)By calling the construct or explicitly (Explicit call)        Eg: Rectangle first = Rectangle (8.5,3.9);

Temporary Instances:

A temporary instance lives in the memory as long it is being used or referenced in an expression and after this it dies. A temporary instance will not have any name. The explicit call to a constructor also allows you to create a temporary instance or temporary object. The temporary instances are deleted when they are no longer referenced.

c) Copy Constructor: A copy constructor is a constructor of the form classname(classname &). The compiler will use the copy constructor whenever you initialize an instance using values of another instance of same type.

Eg:                  Sample S2=S1; //Copy constructor used. Also         Sample S2(S1);

In the above code, for the second statement, the compiler will copy the instance S1 to S2 member by member. If you have not defined a copy constructor, the compiler automatically, creates it and it is public. A copy constructor takes a reference to an object of the same class an argument.

Sample (Sample &s) //Copy Constructor                Copy Constructor is called in three situations

{          i=s.i;                                                   1.  When an object is passed by value

j=s.j;    }};                                          2. When a function returns an object

                                                           3. When you create and initialize with another object

Constructor Overloading:The constructor of a class may also be overloaded so that even with different number and types of initial values, an object may still be initialized.

Default Arguments Versus Overloading: Using default arguments gives the appearance of overloading, because the function may be called with an optional number of arguments.

Special Characteristics of Constructors:

1. Constructor functions are invoked automatically when the objects are created. They have the same name as class

2. If a class has a constructor, each object of that class will be initialized before any use is made of the object.

3. Constructor functions obey the usual access rules. i.e private and protected constructors are available only for

member and friend functions, however, public constructors are available for all the functions. Only the

functions that have access to the constructor of a class, can create an object of the class.

4. No return type (not even void) can be specified for a constructor.

5. They cannot be inherited, though a derived class can call the base class constructor.

6. Like other c++ functions, constructors can also have default arguments.

7. A constructor can be used explicitly to create new objects of its class type, using the syntax class-name

Destructor: A destructor is used to destroy the objects that have been created by a constructor. A destructor destroys the values of the object being destroyed. A destructor is also a member function whose name is the same as the class name but is preceded by tilde(~). A destructor takes no arguments, and no return types can be specified for it (not even void). It is automatically called by the compiler when an object is destroyed. A local object, local to a block, is destroyed when the block gets over; a global or static object is destroyed when the program terminates. A destructor cleans up the storage (memory area of the object) that is no longer accessible.

Need for Destructors: During construction of any object by the constructor, resources may be allocated for use. (for example, a constructor may have opened a file and a memory area may be allotted to it). These allocated resources must be de allocated before the object is destroyed. A destructor performs these types of tasks.

Some Characteristics of Destructors:

1. Destructor functions are invoked automatically when the objects are destroyed when the scope of the object gets over.

2. If a class has a destructor, each object of that class will be de-initialized before the object goes out of scope.(Local objects at the end of the block defining them and    at the end of the program).

3. Destructor functions also, obey the usual access rules as other member functions do.

4.No argument can be provided to a destructor, neither does it return any value.

5. They cannot be inherited nor overloaded.


Source :

Web site link:

Google key word : Notes on constructor and destructor C++ file type : doc

Author : not indicated on the source document of the above text

If you are the author of the text above and you not agree to share your knowledge for teaching, research, scholarship (for fair use as indicated in the United States copyrigh low) please send us an e-mail and we will remove your text quickly.


Notes on constructor and destructor C++


If you want to quickly find the pages about a particular topic as Notes on constructor and destructor C++ use the following search engine:



Notes on constructor and destructor C++


Please visit our home page Terms of service and privacy page




Notes on constructor and destructor C++