Constructors and Destructors

The constructor gets called automatically for each object that has just got created It appears as member function of each class, whether it is defined or not It has the same name as that of the class It may or may not take parameters, does not return any thing and not even void The prototype is - <class name> (<param list>) It guarantees the initialization of the data members of the class Domain constraints on the values of data members can also be implemented via constructors

The compiler embeds a call to the constructor for each object when it is created class A { int x; public : void setx (const int = 0); int getx ; } ; // end of A.h # include”A.h” void main() { A A1 ; } //end of Amain.cpp

The statements are transformed as follows A A1 ; //memory allocated for the object A1.A(); as A(&A1);// constructor called implicitly Similarly, the constructor is called for each object that is created dynamically in the heap by the new operator A * Aptr; Aptr = new A; as 2 statements Aptr = new A; Aptr -> A(); as A(Aptr) ; //constructor called implicitly by the compiler Constructors do not allocate memory for objects but are the member functions that are called after memory has been allocated for the object The compiler prototypes and defines constructor for us with out any statements in the definition

class A { ….. public: A(); // prototype inserted by compiler ….}; A :: A() { } //empty defn. inserted by compiler The compiler defines the constructor in order to resolve the call to the constructor that it compulsorily places for the object being created Explicit call to the constructor for an existing object is forbidden A1.A(); // not legal C++ code If we define constructor, the compiler does not define, but embeds implicit calls to the constructor

Being a non-static member, constructor takes the ‘this’ pointer as a leading formal argument The address of the invoking object is passed as a leading parameter to the constructor call. Hence members of the invoking object can be accessed from with in the definition of the constructor class A { int x; public : A() ; void setx (const int = 0); int getx ; } ; // end of A.h

# include”A.h” #include<iostream.h> A :: A() { cout << “constructor of class A called\n”; } // definitions of rest of functions of class A // end of A.cpp void main() { A A1 ; cout << “ End of Program \n “; } //end of Amain.cpp Output : constructor of class A called End of Program

For the class Distance, we would like to set the values of ‘iFeet’ and ‘fInches’ to 0 and 0.0 { public: Distance (); //our own constuctor //rest of class Distance }; //end of Distance.h #include “Distance.h” Distance :: Distance ( ) { iFeet =0; fInches = 0.0 ; } //definitions of rest of functions of class Distance // end of Distance .cpp

#include “Distance.h” #include<iostream.h> void main() { Distance d1; //constructor called cout<<d1.getFeet()<<””<<d1.getInches()<<endl; } //end of DistTest.cpp Output 0 0.0 There is a guaranteed initialization of data members of the objects of the class Distance The constructor that does not take any arguments – default / zero-argument constructor We define a class instead of character arrays

The class ‘String’ will have two private data members – (i) a character pointer pointing at dynamically allocated block of memory that contains the actual character array (ii) a long unsigned integer containing the length of this array class String { char * cStr; long unsigned int len; public : String(); // prototype of the constructor // rest of the class String }; // end of String.h

Suppose s1 is the object of class String 101 27 cStr 101 3 a b c \0 len s1 Suppose s1 is the object of class String We want to implement the following two conditions (i)cStr should point either to the dynamically allocated block of memory exclusively allocated for it or NULL (ii) There should be no memory leaks When the object of the class is created, cStr should initially set to NULL and len to zero

#include “String.h” String :: String() // definition of the constructor { cStr = NULL ; len = 0 ; } // definitions of rest of functions of class String // end of String.cpp Parameterized constructors Constructors take arguments and can, therefore be overloaded public : Distance(); //part of Distance.h Distance(int, float); // parameterized constructor

Distance :: Distance ( ) { iFeet =0; fInches = 0.0 ; } Distance :: Distance ( int p, float q) { iFeet =p; setInches(q) ; } //function definitions void main() //object created in stack { Distance d1(1, 1.1); //parameterized constructor called cout<<d1.getFeet()<<“ ”<<d1.getInches(); } Output: 1 1.1

void main() //object created in heap { Distance * dPtr; dPtr = new Distance d1(1, 1.1); //parameterized constructor called cout<<dPtr->getFeet()<<“ ”<<d1->getInches(); } Output: 1 1.1 If only the parameterized constructor is provided with out zero-argument one, the compiler will not provide the default constructor. On compiling Distance d1; // ERROR: no matching constructor Hence zero-argument constructor is a must

The formal arguments of the parameterized constructor can be assigned default values But, in that case zero-argument constructor should not be provided, because an ambiguity error will arise when we attempt to create an object with out passing any values for the constructor Distance ( int =0, float = 0.0 ) ; // default values If we write, Distance d1; // ambiguity error Parameterized constructor for class ‘String’ String s1(“abc”); //constructor would handle these char * cPtr=“abc” ; String s1(cPtr) ; //statements char cArr=“abc” ; String s1(Arr) ;