Lecture 4 :

Constructors and
Destructors

Outline
• Default Constructor
• Constructors with Parameters
• Constructor Initializers
• Destructors
• Copy Constructor
• Constant Objects
• Passing Objects to Functions
• Nesting Objects
• Dynamic Members

1
 Initializing Class Objects:
CONSTRUCTORS

 Initialization of every object can be done by providing a special

member function called the constructor.

 The constructor is invoked automatically each time an object

(variable) of that class is created (instantiated).

 There can be more than one constructor of the same class.

 The constructor functions are used for many purposes, such as

assign initial values to data members, open files, etc.

4.3

Constructors
 The constructor can take parameters, but it cannot have a
return value (even not void).

 The constructor must have the same name as the class itself.

 There are three types of constructors:

• Default constructor
• Parameterized constructor
• Copy constructor

4.4

2
 Default Constructor
Default constructor requires no parameters.
class Point{
int x,y;
public:
Point() { // default constructor
x=0;
y=0;
};
bool move(int, int);
void print();
};

int main() {
Point p1, p2; // Default constructor is called (invoked) 2 times.

Point *ptr; // ptr is not an object, constructor is NOT called yet.

ptr = new Point;
// Object is created, also the default constructor is called now.
}
4.5

Constructors with Parameters

 Users of the class (client programmer) can supply constructors with
necessary arguments.

 A class may have more than one constructor with different type of input
parameters (Constructor overloading).

• First constructor is the default constructor.

• Second constructor is the parametered constructor.

// A constructor with Parameters

Point::Point(int x_in, int y_in) {
class Point{
// Point may not have negative coordinates
int x,y;
if ( x_in < 0 ) // If the given value is negative
public:
x = 0; // Assigns zero to x
Point();
else x = x_in;
Point(int, int);
bool move(int, int);
if ( y_in < 0 ) // If the given value is negative
void print();
y = 0; // Assigns zero to y
};
else y = y_in;
}
4.6

3
 int main() {
Point p1(20, 100), p2(-10, 45); // Constructor is called 2 times

Point *ptr = new Point(10, 50); // Constructor is called once

Point p3; //ERROR! There is not a default constructor body

Point p4(10); //ERROR! There isn't a constructor with one parameter

……
}

 To prevent the first compiler error, the following default constructor

should be defined in class codes.

Point() {}

4.7

Default Values of Constructor Parameters

 Parameters of constructors may have default values.
 The following constructor can be called with one, two, or no arguments.

class Point {
public:
Point (int =0, int =0);
// Default values of parameters are zero.
……
};

Point::Point (int x_in, int y_in) { int main() {

if ( x_in < 0 )
Point p1(15, 75); // x=15, y=75
x = 0;
Point p2(100); // x=100, y=0
else x = x_in;
Point p3; // x=0, y=0
if ( y_in < 0 ) }
y = 0;
else y = y_in;
}
4.8

4
 Initializing Arrays of Objects
 When an array of objects is defined, the default constructor of the
class is invoked for each element (object) of the array one at a time.

Point array[10]; // Default constructor is called 10 times

 To invoke a constructor with arguments, a list of initial values can be used.

Point array[3]= { (10) , (20) , (30,40) };

Objects: Arguments:
array[0] x_in = 10 , y_in = 0
array[1] x_in = 20 , y_in = 0
array[2] x_in = 30 , y_in = 40

 To make the program more readable:

Point array[3]= { Point(10) , Point(20) , Point(30,40) };
4.9

Constructor Initializers
 Instead of assignment statements, constructor initializers can be used to
initialize data members of an object.
 Specially, to assign an initial value to a constant member, using the
constructor initializer is the only way.

class S {
const int CI; // constant data member
int x; // nonconstant data member
public:
S( ) { // Constructor
x = 0;
CI = 0; // ERROR! CI is const
}
};

The example below is not correct, either:

class S {
const int CI = 0 ; // ERROR!
int x;
};
4.10

5
 For constant data members, a constructor initializer have to be written.

class S {
const int CI; // constant data member
int x; // nonconstant data member

public:
S() : CI(0)
// initial value of CI assigned to zero
// (constructor initializer)

{ x = 0; } // end of constructor
};

4.11

 In fact, all data members of a class can be initialized by using constructor

initializers.

class S {
const int CI; // constant data member
int x; // nonconstant data member

public:
S(int a, int b) : CI (a), x (b) // Constructor
{ } // Codes may be empty
};

 Two objects are defined in main.

int main() {
S obj1 (-5, 1);
S obj2 (0, 18);
}

4.12

6
 DESTRUCTORS
 The destructor function is called automatically,
• when each of the objects goes out of scope, or
• when a dynamic object is deleted from memory by using the
delete operator.

 A destructor is defined as having the same name as the class, with a

tilde ( ~ ) symbol preceded to class name.

 A destructor has no return type and receives no parameters.

 A class may have only one destructor.

4.13

Example : String class

A user defined String class :

class String{
int size; // Length (number of chars) of the string
char *contents; // Contents of the string
public:
String(const char *); // Constructor
void print(); // An ordinary member function
~String(); // Destructor
};

size
*contents t e x t \0

Note: C++ contains a built-in string class (lowercase).

Programmers don't need to write their own String class.
4.14

7
 Constructor : Copies the input character array to the contents of
the String.

String::String(const char *in_data) {

size = strlen(in_data);
// strlen is a built-in function of the cstring library

contents = new char[size +1];

// +1 is for the null ( '\0' ) character

strcpy(contents, in_data);
// input data is copied to the contents
}

4.15

// Destructor
// Memory pointed by contents is given back

String::~String() {
delete[] contents;
}

void String::print() {
cout << contents << " " << size << endl;
}

int main() {
String s1("ABC");
String s2("DEFG");
// constructor is called two times

s1.print();
s2.print();

// At the end of program,

// destructor is called two times
} 4.16

8
 Copy Constructor

 Copy constructor is used to copy the members of an object

to a new object.

 The type of its input parameter is a reference to objects

of the same type.

 The input parameter is the object that will be copied into

the new object.

 There are two types of Copy constructor:

• Compiler-provided
• User-written

4.17

Compiler-provided Copy Constructor

•There is a compiler-provided copy constructor.

• Compiler-provided copy constructor will simply copy the

contents of the original into the new object,
as a byte-by-byte copy.

• If there is a pointer as a class member, so a byte-by-byte

copy would copy the pointer from one to the other.

• In result, they would both be pointing to the same allocated

member.

4.18

9
 Compiler-provided Copy Constructor
int main()
{
String s1("ABCDE"); // Normal constructor is called
s1.print();

String s2 = s1;
// Compiler-provided copy constructor is called in assignment
}

First object (s1) Second object (s2)

size 5 5 size
contents 0x008d0080 0x008d0080 contents

A B C D E \0

4.19

User-written Copy Constructor

 The copy constructor, generated by the compiler can not copy the
data in the memory locations pointed by the member pointers.
 The programmer must write his own copy constructor function.

First object (s1) Second object (s2)

size 5 5 size
contents 0x008d0080 0x00ef0070 contents
A A
B B
C C
D D
E E
\0 \0

4.20

10
 Example: User-written copy constructor
class String{ // User defined String class
int size;
char *contents;

public:
String(const char *); // Normal Constructor
String(const String &); // Copy Constructor (user-written)
void print(); // Prints the string on the screen
~String(); // Destructor
};

// Copy Constructor (user-written)

String::String(const String & object_in) {

{
size = object_in.size;
contents = new char[size + 1]; // +1 is for null character
strcpy(contents, object_in.contents);
}

4.21

int main() { // Test program

String s1("ABCDE");

s1.print();

String s2 = s1; // Copy constructor is invoked (user-written)

String s3(s1); // Copy constructor is invoked (user-written)

s2.print();

s3.print();
}

4.22

11
 Const Member Function
 Programmer may declare some member functions as const,
which do not modify any data of the object.

class Point {
int x, y;
public:
Point(int, int);
bool move(int, int);
void print() const; // Constant function
};

// Constant function
void Point::print() const {
cout << "X= " << x << ", Y= " << y << endl;
}

4.23

Constant Object
 The programmer may use the keyword const to specify that an object
is not modifiable.

int main() { // Test program

const Point A(10,20); // A is a constant object

A.print(); // OK. Const function operates on const object
A.move(30,15); // ERROR! Non-const function on const object
// A is not modifiable

Point B(0,50); // B is a non-constant object

B.print(); // OK.
B.move(100,45); // OK.
}

4.24

12
 Static Class Members
 In certain cases, only one copy of a particular data member should be
shared by all objects of a class.
 A static data member is used for this reason.
• Static data members exist even no objects of that class exist.
• To access public static data without an object, use the class name and
the scope operator. For example A::i= 5;

class A {
public:
static int i;
};

int A::i ; //Required definition

• Objects p,q,r share the
int main() { same member data i.
A p, q, r; • Program displays the
A::i = 5; same outputs.
cout << A::i ;
cout << p.i ;
cout << q.i ;
cout << r.i ;
} 4.25

Passing Objects to Functions as Arguments

 As a general rule, when calling a function, objects should be passed by-
reference.
 In this way, an unnecessary copy of an object is not passed as argument.
 Also to prevent the function from modifying the original object, we make the
parameter a const reference.

ComplexT ComplexT::add (const ComplexT & z) {

ComplexT result; // local temporary object
result.re = re + z.re;
result.im = im + z.im;
return result;
}

int main() {
ComplexT z1(1, 2) , z2(0.5, -1) , z3;
// Three objects are defined
z3 = z1.add( z2 ); // pass z2 object as argument
z3.print();
}
4.26

13
 Avoiding Temporary Objects
 In the previous example, within the add function, a temporary local object
(result) is defined to add two complex numbers.

 Because of this object, constructor and destructor are called.

 Avoiding a local temporary object within add function saves memory space.

ComplexT ComplexT::add (const ComplexT & c) {

double re_new, im_new;
re_new = re + c.re;
im_new = im + c.im;
return ComplexT(re_new, im_new);
// Constructor is called, then whole object is returned
}

4.27

NESTING OBJECTS:
Classes as Members of Other Classes

 A class may include objects of other classes as its data members.

 In the following example, School class includes an array of Student class
objects.

class School class Student

{ {
public: public:
Student st[2000]; int ID;
string firstname;
School(); //constructor string lastname;
void print_school();
.... Student(int, string, string); //constructor
}
void print_student();
...
}

14
 Student class

// Constructor
Student:: Student(int ID, string fname, string lname)
{
this->ID = ID;
firstname = fname;
lastname = lname;
}

void Student ::print_student()

{
cout << ID << " " << firstname << " " << lastname << endl;
}

4.29

School class

School::School()
{
// Default Constructor
for (int i=0; i <= 2000; i++)
st[i].ID = 0;
st[i].firstname = "";
st[i].lastname = "";
};

School::print_school()
{
for (int i=0; i <= 2000; i++) {
if ( st[i].ID != 0]
st[i].print_student(); // Call print function of Student
}

4.30

15
 Main program

int main()
{
School Sch; //Definition invokes the constructor of School

// Add 3 students with constructors

Sch.st[0] = Student(111, "AAA", "BBB");
Sch.st[1] = Student(222, "CCC", "DDD");
Sch.st[2] = Student(333, "EEE", "FFF");

Sch.print_school(); //Call print function of school Sch

4.31

16