Week 9-10

Outline
• Constructors
• Destructors
• Friend functions
• This pointer
• Dynamic Memory allocation with NEW and DELETE
operators

1
 Constructors
• Constructor function
– Special member function
• Initializes data members
• Same name as class
– Called when object instantiated
– Executed automatically whenever an
object is created
– No return type

2
•
An example of constructor
1 // counter.cpp
• 2 // An example of a constructor
• 3 #include <iostream.h>
• 4
• 5
• 6
• 7
• 8 class test
• 9 {
• 10 public:
• 11 test() { cout << “I am constructor” <<endl; } // constructor
• 12 abc() { cout << “ok” <<endl; }
• 13 };
• 14 int main()
• 15 {
• 16 test a,b,c; //define and initialize
• 17
• 18 return 0; // indicates successful termination
• 19
• 20 } // end main
I am constructor
I am constructor
I am constructor

• In the above program, when the three objects a,b

and c are created, each time an object is created,
the constructor function is automatically
executed and prints “i am constructor” three
 Another example of
•
•
1
2
constructor
// counter.cpp
// An example of a constructor
• 3 #include <iostream>
• 4
• 5
• 6
• 7 class Counter
• 8 {
• 9 private:
• 10 unsigned int count; // count
• 11 public:
• 12 Counter() { count=0; } // constructor
• 13 void inc_count() { count++; } // increment count
• 14 int get_oount() { return count; } // return count
• 15 };
• 16 int main()
• 17 {
• 18 Counter c1,c2; //define and initialize
• 19 cout <<“\nc1= “ <<c1.get_count(); //display
• 20 cout <<“\nc2= “ <<c2.get_count();
• 21 c1.inc_count(); //increment c1
• 22 c2.inc_count(); //increment c2
• 23 c2.inc_count(); //increment c2 again
• 24 cout << “\nc1=“ <<c1.get_count(); //display again
• 25 cout << “\nc2=“ <<c2.get_count();
• 26 return 0; // indicates successful termination
• 27
• 28 } // end main
c1=0
c2=0
c1=1
c2=2
 Constructors (con’t)
• In the previous example, when an object of type
Counter is first created, we want it to be
initialized to 0.
• Alternatively, we could provide a zero_count()
function, which could always set count to 0.
However, same function needs to be executed
every time we created a Counter object.
Counter c1;
c1.zero_count();
• This function is called automatically whenever an
object of type Counter is created. i.e.
Counter c1,c2; //creates objects of type
Counter
• This function sets the count variable to 0. so the
effect of this single statement is to not only
 Copy Constructor
• We can also initialize an object with
another object of the same type
• Surprisingly, we don’t need to create
a special constructor for this; one is
already built into all classes. It is
called the default copy constructor
• It’s one-argument constructor whose
argument is an object of the same
class as the constructor
 An example of Copy
•
•
#include <iostream.h>
#include <conio.h>
constructors
• class Distance
• {
• private:
• int feet;
• float inches;
• public:
• Distance() //no-arg constructor
• { }
• Distance (int ft, float in) //two-arg constructor
• {
• feet=ft;
• inches=in;
• }
• void getdist()
• {
• cout<<"\nEnter feet: "; cin>>feet;
• cout<<"\nEnter inches: "; cin>>inches;
• }
• void showdist()
• {
• cout<<feet<<"\'"<<inches<<'\"';}
• };
• void main()
• {
• clrscr();
• Distance dist1(11,6.25); //initialize dist1 constructor
• Distance dist2(dist1); //pass object dist1 to constructor Distance
• Distance dist3=dist1; //assign object that contained value to dust3 object

• cout<<"\ndist1= ";
• dist1.showdist();
• cout<<"\ndist2= ";
• dist2.showdist();
• cout<<"\ndist3= ";
• dist3.showdist();
• getch();
• } // end main
dist1= 11’6.25”
dist2= 11’6.25”
dist3= 11’6.25”
 Overloaded constructors
• More than one constructor functions can be
defined in one class
• When more than one constructor functions are
defined, each constructor is defined with a
different set of parameters
• “Defining more than one constructor with same
name but different set of parameters is called
constructor overloading”
• Constructor overloading is used to initialize
different values to class objects
• When a program that uses the constructor
overloading is compiled, C++ complier checks
the number of parameters, their order and data
types and marks them differently
 Another example of
constructor overloading
• 1 // constructor1.cpp
• 2 // An example of a constructor overloading
• 3 #include <iostream>
• 4
• 5
• 6
• 7
• 8 class sum
• 9 {
• 10 public:
• 11 sum (int l, int m, int n) // three-arg constructor
• 12 { cout << “Sum of 3 integers is=“ << (l+m+n) <<endl; }
• 13 sum (float l, float m) // two-arg constructor
• 14 { cout << “Sum of 2 float is=“ << (l+m) <<endl; }
• 15 };
• 16
• 17 void main()
• 18 {
• 19 sum x(6.2,2.2), y(7,6,8);
• 20 } // end main
Sum of 2 float is=8.4
Sum of 3 integers is=21

• In this above program, when the program is

executed, the object x is created first and then
the sum constructor function that has two
integer type parameters is executed and
similarly y object is created and the sum
constructor function that has three integer type
parameters is executed
 Destructors
• Destructors
– Another function is called, when an object is
destroyed
– Same name as class
• Preceded with tilde (~)
– No arguments
– Cannot be overloaded
– Do not have a return value
– Take no arguments
– Deallocate memory that was allocated for the
object by the constructor
– Performs “termination housekeeping
 Destructor example
• class Foo
{
private:
int data;
public:
Foo() { data = 0; }
//constructor
~Foo() { }
//destructor
};
 An example of destructor
• 1 // constructor1.cpp
• 2 // An example of a destructor
• 3 #include <iostream>
• 4
• 5
• 6
• 7
• 8 class ping
• 9 {
• 10 public:
• 11 ping() //no-arg constructor
• 12 { cout << “This is a constructor function”<<endl; }
• 13 ~ping() //destructor
• 14 { cout << “This is a destructor function”<<endl; }
• 15 };
• 16
• 17 int main()
• 18 {
• 19 ping x;
• 20 int a,b;
• 21 a=10;
• 22 b=20;
• 23 cout<<“The sum of two numbers is=“<<(a+b)<<endl;
• 24
• 25 return 0; // indicates successful termination
• 26 } // end main
This is a constructor function
The sum of two numbers is=30
This is a destructor function

• In this above program, when the program is

executed, the constructor function is called,
then prints out the sum of values of a and b, and
then atlast the destructor function is executed
 When Constructors and
Destructors Are Called
• Order of constructor, destructor function
calls
– Global scope objects
• Constructors
– Before any other function (including main)
• Destructors
– When main terminates (or exit function called)
– Not called if program terminates with abort
– Automatic local objects
• Constructors
– When objects defined
» Each time execution enters scope
• Destructors
– When objects leave scope
18 » Execution exits block in which object defined
 When Constructors and
Destructors Are Called
• Order of constructor, destructor
function calls
• Constructors
– Exactly once
– When execution reaches point where object
defined
• Destructors
– When main terminates or exit function called
– Not called if program ends with abort

19
 Friend Functions
• Friends functions
– Non-member functions should be able to
access an object’s private or protected data
– Free up the concept of data encapsulation and
data hiding
– Acts as a bridge b/w two classes
• Declaring friends
– Function
• Precede function prototype with keyword friend
– All member functions of class ClassTwo as friends of
class ClassOne
• Place declaration of form
friend class ClassTwo;
in ClassOne definition
 An example of friends
•
•
•
1
2
3
function
// friend.cpp
// An example of a friend function
#include <iostream>
• 4
• 5
• 6
• 7 class beta; //needed for frifunc declaration
• 8 class alpha
• 9 {
• 10 private:
• 11 int data;
• 12 public:
• 13 alpha() { data=3; } // no-arg constructor
• 14 friend frifunc (alpha, beta); // friend function
• 15 };
• 16 class beta
• 17 {
• 18 private:
• 19 int data;
• 20 public:
• 21 beta() { data=7; } // no-arg constructor
• 22 friend frifunc (alpha, beta); // friend function
• 23 };
• 24 int frifunc(alpha a, beta b) //function declaration
• 25 { return (a.data + b.data); }
• 26 int main()
• 27 {
• 28 alpha aa;
• 29 beta bb;
• 30 cout << frifunc (aa, bb); //call the function
• 31 return 0; // indicates successful termination
• 32
• 33 } // end main
10
 Friend function (con’t)
• In the previous example, we make frifunc() to have access
to both private data members, so we make it a friend
function
• It is declared with the friend keyword in both classes:
friend int frifunc(alpha, beta); // can be placed anywhere in the
class, does’nt matter if it goes in the public or the private
section
• An object of each class is passed as an argument to the
function frifunc(), and it accesses the private data member
of both classes through these arguments.
• The function does’nt do much: add the data items and
returns the sum. The main() program calls this function and
prints the result
• Note: class “beta” is referred to in the declaration of the
function frifunc() in the class “alpha”, so “beta” must be
declared before “alpha”. Hence the declaration
 Another example of friends
•
•
1
2
function
// friend1.cpp
// An example of a friend function
• 3 #include <iostream>
• 4
• 5
• 6 class y; //needed for frifunc declaration
• 7
• 8 class x
• 9 {
• 10 private:
• 11 int m;
• 12 public:
• 13 x() { m=10; } // no-arg constructor
• 14 friend int abc (a,b); // friend function
• 15 };
• 16 class y
• 17 {
• 18 private:
• 19 int n;
• 20 public:
• 21 y() { n=10; } // no-arg constructor
• 22 friend int abc (a,b); // friend function
• 23 };
• 24 int abc (x c1, y c2 ) //function declaration
• 25 { return (c1.m + c2.n); }
• 26 int main()
• 27 {
• 28 x a;
• 29 y b;
• 30 cout << Sum of two numbers = “<<abc (a, b); //call the function
• 31 return 0; // indicates successful termination
• 32
• 33 } // end main
sum of two numbers=20
 Friend function (con’t)
• In the previous example, we make abc() to have access to
both private data members, so we make it a friend function
• It is declared with the friend keyword in both classes:
friend int abc(a, b); // can be placed anywhere in the class,
does’nt matter if it goes in the public or the private section
• An object of each class is passed as an argument to the
function abc(), and it accesses the private data member of
both classes through these arguments.
• The function does’nt do much: add the data items and
returns the sum. The main() program calls this function and
prints the result
• Note: class “y” is referred to in the declaration of the
function abc() in the class “x”, so “y” must be declared
before “x”. Hence the declaration
class y; //at the beginning of the program
 Friend classes
• The member functions of a class can
all be made friends at the same time
when you make the entire class a
friend
• The program FRICLASS shows how
this looks
•
An example of friends class
1 // friendclass.cpp
• 2 // An example of a friend classes
• 3 #include <iostream>
• 4
• 5
• 6
• 7 class alpha
• 9 {
• 10 private:
• 11 int data1;
• 12 public:
• 13 alpha() { data1=99; } // no-arg constructor
• 14 friend class beta; // beta is a friend class
• 15 };
• 16 class beta
• 17 { // all member functions can
• 18 public: // access private alpha data
• 19 void func1(alpha a) { cout << “\ndata1=“ <<a.data1; }
• 20 void func2(alpha a) { cout << “\ndata1=“ <<a.data1; }
• 21 void func3(alpha a) { cout << “\ndata1=“ <<a.data1; }
• 22 };
• 23 int main()
• 24 {
• 25 alpha aa;
• 26 beta bb;
• 27 bb.func1(aa);
• 28 bb.func2(aa);
• 29 bb.func3(aa);
• 28 return 0; // indicates successful termination
• 29
• 30 } // end main
data1=99
data1=99
data1=99
 Friend classes (con’t)
• In the class “alpha” the entire class
“beta” is proclaimed a friend
• Now all the member functions of
“beta” can access the private data of
“alpha” (in this program the single
data item data1)
• Note that in the friend declaration we
specify that “beta” is a class using
the class keyword:
friend class beta;
 friend Functions and friend 
Classes (con’t)
• Properties of friendship
– Friendship granted, not taken
• Class B friend of class A
– Class A must explicitly declare class B friend
– Not symmetric
• Class B friend of class A
• Class A not necessarily friend of class B
– Not transitive
• Class A friend of class B
• Class B friend of class C
31 • Class A not necessarily friend of Class C
 Using the this Pointer
• this pointer
– Allows object to access own address
– Implicitly reference member data and
functions
– Magic pointer named “this”, which points
to the object itself
– To find out the address of the object of
which it is a member
– Can also be treated like any other
pointer to an object, and can be used to
access the data in the object it points to

32
 An example of without this
•
•
•
1
2
3
pointer
// where.cpp
// An example of a this pointer
#include<iostream.h>
• 4 #include<conio.h>
• 5 class A
• 6 {
• 7 private:
• 8 int a;
• 9 int b;
• 10
• 11
• 12 public:
• 13
• 14 void getdata(int a, int c)
• 15 {
• 16 a = a;
• 17 b = c;
• 18 }
• 19 void display()
• 20 {
• 21 cout<<"\n"<<a;
• 22 cout<<"\n";
• 23 cout<<b<<"\n";
• 24 }
• 25 };
• 26 int main()
• 27 {
• 28 clrscr();
• 29 A obj1;
• 30 obj1.display();
• 31 obj1.getdata(2, 4);
• 32 obj1.display();
• 33 getch();
• 34 } return 0; // indicates successful termination
• 25
• 26 } // end main
0
7713

0
4
 An example of with this
•
•
•
1
2
3
pointer
// where.cpp
// An example of a this pointer
#include<iostream.h>
• 4 #include<conio.h>
• 5 class A
• 6 {
• 7 private:
• 8 int a;
• 9 int b;
• 10
• 11
• 12 public:
• 13
• 14 void getdata(int a, int c)
• 15 {
• 16 this->a = a;
• 17 b = c;
• 18 }
• 19 void display()
• 20 {
• 21 cout<<"\n"<<a;
• 22 cout<<"\n";
• 23 cout<<b<<"\n";
• 24 }
• 25 };
• 26 int main()
• 27 {
• 28 clrscr();
• 29 A obj1;
• 30 obj1.display();
• 31 obj1.getdata(2, 4);
• 32 obj1.display();
• 33 getch();
• 34 } return 0; // indicates successful termination
• 25
• 26 } // end main
0
7713

2
4
•
An example of this pointer
1 // where.cpp
• 2 // An example of a this pointer
• 3 #include <iostream>
• 4
• 5
• 6
• 7 class where
• 9 {
• 10 private:
• 11 char carray[10]; //occupies 10 bytes
• 12 public:
• 13 void reveal()
• 14 { cout << “\nMy object’s address is” << this; }
• 15 };
• 16 int main()
• 17 {
• 18 where w1,w2,w3; //make three objects
• 19 w1.reveal(); //see where they are
• 20 w2.reveal();
• 21 w3.reveal();
• 22 return 0; // indicates successful termination
• 23
• 24 } // end main
My object’s address is 0x8f4effec
My object’s address is 0x8f4effe2
My object’s address is 0x8f4effd8
 this pointer (con’t)
• In the previous example, the main()
program creates three objects of type
“where”
• It then asks each object to print its
address, using the reveal() member
function
• The function reveal() prints out the value
of the this pointer
• Since the data in each object consists of
an array of 10 bytes, the objects are 10
bytes apart in the memory
 Accessing Member Data
with “this”
• When you call a member function, it
comes into existence with the value
of “this” set to the address of the
object for which it was called
• The “this” pointer can be treated like
any other pointer to an object, and
can thus be used to access the data
in the object it points to as shown in
dothis.cpp program:
 Another example of this
•
•
•
1
2
3
pointer
// dothis.cpp
// the this pointer referring to data
#include <iostream>
• 4
• 5 using std::cout;
• 6 using std::endl;
• 7 class what
• 9 {
• 10 private:
• 11 int alpha;
• 12 public:
• 13 void tester()
• 14 { this-> alpha = 11; //same as alpha = 11
• 15 cout << this->alpha; } //same as cout << alpha
• 16 };
• 17 int main()
• 18 {
• 19 what w;
• 20 w.tester();
• 21 return 0; // indicates successful termination
• 22
• 23 } // end main
11
 this pointer (con’t)
• This previous program prints out the
value 11
• Notice that the tester() member
function accesses the variable
“alpha” as
this->alpha
• This is exactly the same as referring
to alpha directly
 Dynamic Memory Management 
with Operators new and delete
• new
– Consider
Time *timePtr;
timePtr = new Time;
– new operator
• Creates object of proper size for type Time
– Error if no space in memory for object
• Calls default constructor for object
• Returns pointer of specified type
– Providing initializers
double *ptr = new double( 3.14159 );
Time *timePtr = new Time( 12, 0, 0 );
– Allocating arrays
int *gradesArray = new int[ 10 ];

44
 Dynamic Memory Management 
with Operators new and delete
• delete
– Destroy dynamically allocated object and free
space
– Consider
delete timePtr;
– Operator delete
• Calls destructor for object
• Deallocates memory associated with object
– Memory can be reused to allocate other objects
– Deallocating arrays
delete [] gradesArray;
– Deallocates array to which gradesArray points
• If pointer to array of objects
45
» First calls destructor for each object in array
» Then deallocates memory
 An example of new and delete
operator
• 1 // newintro.cpp
• 2 // introduces operator new and delete operator
• 3 #include <iostream.h>
• 4 #include <string.h> //for strcpy
• 5
• 6
• 7
• 8 int main()
• 9
• 10 {
• 11 char *str = “idle hands are the devil’s workshop.”;
• 12 int len = strlen(str); //get length of str
• 13 char *ptr; //make a pointer to char
• 14 ptr = new char[len+1] //set aside memory: string
• 15 strcpy(ptr,str) //copy str to new memory area ptr
• 16 cout << endl << “ptr =“ << ptr; //show that str is now in ptr
• 17 delete[] ptr; //release ptr’s memory
• 18 return 0; // indicates successful termination
• 19
• 20 } // end main
idle hands are the devil’s workshop.
 Syntax of new operator
char * ptr;

Pointer

ptr = new char[len+1];

Number of type
Keyword char variables
Data type of
variables
Memory obtained by new
operator
f700
ptr
f700

Memory obtained by Len+1

ptr = new char[len+1]

 Delete operator
ptr = new someclass; //allocate a
single //object
delete ptr //no brackets
//following
delete
 An example of new and delete
•
•
1
2
operator
// newintro.cpp
// using new to get memory for strings
• 3 #include <iostream.h>
• 4 #include <string.h> //for strcpy, etc
• 5
• 6
• 7
• 8 class String //user-defined string type
• 9 {
• 10 private:
• 11 char* str; //pointer to string
• 12 public:
• 13 String (char* s) //constructor, one arg
• 14 {
• 15 int length = strlen(s); //length of string argument
• 16 str = new char[length]; //get memory
• 17 strcpy(str, s); //copy argument to it
• 18 }
• 19 ~String() //destructor
• 20 {
• 21 delete[] str; //release memory
• 22 }
• 23 void display() //display the string
• 24 {
• 25 cout <<“s1= “<<str;
• 26 } };
• 27 int main()
• 28 {
• 29 String s1 = “Who knows nothing doubts nothing.”;
• 30 s1.display();
• 32 return 0; // indicates successful termination
• 33
• 34 } // end main
a1=Who knows nothing doubts nothing.