Unit 2

18CSC202J- Object Oriented

Design and Programming

Unit II

Types of Constructor

1/26/2023 Constructor's 2
Agenda :
1) To understand types of Constructor’s.
2) To apply Constructor’s in real time example.

1/26/2023 Constructor's 3
 CONSTRUCTORS
• It is very common for some part of an object to require
initialization before it can be used.

• Suppose you are working on 100's of objects and the default

value of a particular data member is needed to be zero.

• Initializing all objects manually will be very tedious job.

• Instead, you can define a constructor function which initializes

that data member to zero. Then all you have to do is declare
object and constructor will initialize object automatically
 CONSTRUCTORS
• While defining a constructor you must remember that the
name of constructor will be same as the name of the class, and
constructors will never have a return type.
 CONSTRUCTORS
• Constructors can be defined either inside the class definition or
outside class definition using class name and scope
resolution :: operator.
 CONSTRUCTOR CHARACTERS
• They must be declared in the public scope.

• They are invoked automatically when the objects are created.

• They do not have return types, not even void and they cannot
return values.

• They cannot be inherited, though a derived class can call the

base class constructor.

• Like other C++ functions, Constructors can have default

arguments.
• Constructors cannot be virtual.

• We can not refer to their addresses.

• An object with a constructor (or destructor) can not be used as

a member of a union.

• They make ‘implicit calls’ to the operators new and delete

when memory allocation is required.
 CONSTRUCTOR TYPES

• Constructors are of three types:

• Default Constructor
• Parameterized Constructor
• Copy Constructor
 DEFAULT CONSTRUCTOR

• Default constructor is the constructor which doesn't take any

argument. It has no parameter.
• Syntax :
 DEFAULT CONSTRUCTOR

• Example

• Output : 10
 DEFAULT CONSTRUCTOR

• As soon as the object is created the constructor is called which initializes its
data members.

• A default constructor is so important for initialization of object members, that

even if we do not define a constructor explicitly, the compiler will provide a
default constructor implicitly.
 DEFAULT CONSTRUCTOR

Output: 0 or any random value

 In this case, default constructor provided by the compiler will

be called which will initialize the object data members to
default value, that will be 0 or any random integer value in this
case.
 PARAMETERIZED CONSTRUCTOR
• These are the constructors with parameter.

• Using this Constructor you can provide different

values to data members of different objects, by
passing the appropriate values as argument.
PARAMETERIZED CONSTRUCTOR

 OUTPUT
10
20
30
 PARAMETERIZED CONSTRUCTOR

 By using parameterized constructor in above case, we have

initialized 3 objects with user defined values. We can have
any number of parameters in a constructor.
 COPY CONSTRUCTOR

• These are special type of Constructors which takes an object as

argument, and is used to copy values of data members of one object
into other object.
 COPY CONSTRUCTOR

• These are special type of Constructors which takes an object as

argument, and is used to copy values of data members of one object
into other object.

• It is usually of the form X (X&), where X is the class name. The

compiler provides a default Copy Constructor to all the classes.
 COPY CONSTRUCTOR

• As it is used to create an object, hence it is called a constructor. And, it creates a new object,
which is exact copy of the existing copy, hence it is called copy constructor.
COPY CONSTRUCTOR
 COPY CONSTRUCTOR

 Output :
 Normal constructor : 10 15
 Copy constructor : 10 15
 STATIC CONSTRUCTOR

• C++ doesn’t have static constructors but you can emulate them using a static instance of a nested
class.

class has_static_constructor {
friend class constructor;
struct constructor {
constructor() { /* do some constructing here … */ }
};
static constructor cons;
};

// C++ needs to define static members externally.

has_static_constructor::constructor has_static_constructor::cons;
Try out program

1/26/2023 Constructor's 23
Questions
1. What is a copy constructor?
a) A constructor that allows a user to move data from one object to another
b) A constructor to initialize an object with the values of another object
c) A constructor to check the whether to objects are equal or not
d) A constructor to kill other copies of a given object.
2. What happens if a user forgets to define a constructor inside a class?
a) Error occurs
b) Segmentation fault
c) Objects are not created properly
d) Compiler provides a default constructor to avoid faults/errors.
3. How many parameters does a copy constructor require?
a) 1
b) 2
c) 0
d) 3

1/26/2023 Constructor's 24
 Unit 2-
Polymorphism -
OVERLOADING
 Introduction

• The word “polymorphism” means having many forms.

• In simple words, we can define polymorphism as the ability of a
message to be displayed in more than one form
 Types of Polymorphism
• Basically, there are two types of polymorphism:
• Compile time (or static) polymorphism
• Run-time (or dynamic) polymorphism.
• Static polymorphism -> Method overloading - calls a function using the best
match technique or overload resolution.

© Oxford University Press 2015. All rights reserved.

 Overloading in C++
✓What is overloading?
– Overloading means assigning multiple meanings to a function name
or operator symbol
– It allows multiple definitions of a function with the same name, but
different signatures.
✓C++ supports
– Function overloading
– Operator overloading
 Why is Overloading Useful?
• Function overloading allows functions that conceptually perform the
same task on objects of different types to be given the same name.

• Operator overloading provides a convenient notation for manipulating

user-defined objects with conventional operators.
 Operator Overloading
• Operator overloading
• Enabling C++’s operators to work with class
objects
• Using traditional operators with user-defined
objects
• Requires great care; when overloading is
misused, program difficult to understand

30
 Operator Overloading
• Examples of already overloaded operators
• Operator << is both the stream-insertion operator and the
bitwise left-shift operator
• + and -, perform arithmetic on multiple types
• Compiler generates the appropriate code based on the
manner in which the operator is used
General Rules for Operator Overloading
• Overloading an operator - Write function definition as normal
Syntax:
returnType classname::operator op(arguments)
{
Function body;
} Function name is keyword operator followed by the symbol for the
operator being overloaded

32
General Rules for Operator Overloading
• Using operators
• To use an operator on a class object it must be overloaded
unless the assignment operator(=)or the address
operator(&)
• Assignment operator by default performs memberwise
assignment
• Address operator (&) by default returns the address of
an object
Steps
1. Create a class that is to be used
2.Declare the operator function in the public part of the class. It may be
either member function or friend function.
3.Define operator function to implement the operation required
4.Overloaded can be invoked using the syntax such as: op x;
 Restrictions on Operator Overloading

Following C++ Operator can’t be overloaded

•Class member access operators(. & .*)
•Scope Resolution Operator(::)
•Sizeof Operator(sizeof())
•Conditional Operator(? :)

35
 Restrictions on Operator Overloading
• Overloading restrictions
• Precedence ,associativity, arity (number of operands) of
an operator cannot be changed
• No new operators can be created
• Use only existing operators
• No overloading operators for built-in types
• Cannot change how two integers are added

36
 Overloadable Operators

+ - * / % ^
& | ~ ! , =
< > <= >= ++ --
<< >> == != && ||
+= -= /= %= ^= &=
|= *= <<= >>= [] ()
-> ->* new new [] delete delete []

Non-overloadable Operators

:: .* . ?:
 Approaches
• Operator Overloading can be done by using three approaches, they
are

1.Overloading unary operator.

2.Overloading binary operator.
3.Overloading binary operator using a friend function.
 Overloading the assignment operator
• The assignment operator (operator=) is used to copy values from one object to another already
existing object.
Assignment vs Copy constructor
• The purpose of the copy constructor and the assignment operator are almost equivalent -- both copy
one object to another.
• However, the copy constructor initializes new objects, whereas the assignment operator replaces the
contents of existing objects.

• The difference between the copy constructor and the assignment operator causes a lot of confusion
for new programmers, but it’s really not all that difficult. Summarizing:

• If a new object has to be created before the copying can occur, the copy constructor is used (note: this
includes passing or returning objects by value).
• If a new object does not have to be created before the copying can occur, the assignment operator is
used.
#include <iostream>
using namespace std;
class Distance {
private: int feet; // 0 to infinite
int inches; // 0 to 12
public: // required constructors
Distance() { feet = 0; inches = 0; }
Distance(int f, int i)
{ feet = f; inches = i; }
void operator = (const Distance &D )
{ feet = D.feet; inches = D.inches; }
// method to display distance
void displayDistance() { cout << "F: " << feet << " I:“ << inches << endl;
} };
int main()
{ Distance D1(11, 10), D2(5, 11);
cout << "First Distance : "; D1.displayDistance();
cout << "Second Distance :"; D2.displayDistance();
// use assignment operator
D1 = D2; cout << "First Distance :";
D1.displayDistance(); return 0; }

Output:
First Distance : F: 11 I:10 Second Distance :F: 5 I:11 First Distance :F: 5 I:11
// CPP program to illustrate
Binary Operator Overloading
// Operator Overloading
#include<iostream>
using namespace std;
class Complex {
private:
int real, imag;
public:
Complex(int r = 0, int i =0) {real = r; imag = i;}
// This is automatically called when '+' is used with
// between two Complex objects
Complex operator + (Complex const &obj) {
Complex res;
res.real = real + obj.real;
res.imag = imag + obj.imag;
return res;
}
void print() { cout << real << " + i" << imag << endl; }
};

int main()
{
Complex c1(10, 5), c2(2, 4);
Complex c3 = c1 + c2; // An example call to "operator+"
c3.print();
}
Operator Overloading MCQ
1) Which is the correct example of a unary operator?
a) &
b) ==
c) —
d) /
2) What is a binary operator give example?
a) Operator that performs its action on a single operand, ++
b) Operator that performs its action on two operand , --
c) Operator that performs its action on three operand , Dereferencing
operator(*)
d) Operator that performs its action on any number of operands , +
Given the following C++ code. How would you define the < operator for Box class so that
when boxes b1 and b2 are compared in if block the program gives correct result?
#include <iostream>
#include <string>
using namespace std;
class Box {
int capacity;
public: Box(){}
Box(double capacity){
this->capacity = capacity; } };
int main(int argc, char const *argv[]) {
Box b1(10);
Box b2 = Box(14);
if(b1 < b2){
cout<<"Box 2 has large capacity.";
} else{
cout<<"Box 1 has large capacity.";
} return 0; }
Answers:
a) bool operator<(Box b) { return this->capacity < b.capacity ? true : false; }
b) bool operator<(Box b) { return this->capacity > b.capacity ? true : false; }
c) bool operator<(Box b) { return b1 > b2 ? true : false; }
d) bool operator<(Box b) { return this < b ? true : false; }
Function Overloading
Agenda :
1) To understand about method overloading
2) To apply method overloading in real time example.

1/26/2023 Method Overloading 46

Function Overloading

• Is the process of using the same name for two or more functions
• Requires each redefinition of a function to use a different function
signature that is:
• different types of parameters,
• or sequence of parameters,
• or number of parameters
• Is used so that a programmer does not have to remember multiple
function names
 Method Overloading
• Method overloading is a feature in C++ that allows creation of
several methods with the same name but with different
parameters.

• For example, print(), print(int), and print("Hello") are

overloaded methods.

• While calling print() , no arguments are passed to the function

• When calling print(int) and print("Hello") , an integer and a

string arguments are passed to the called function.

• Allows one function to perform different tasks

1/26/2023 Method Overloading 48

MATCHING FUNCTION CALLS WITH OVERLOADED METHODS

When an overloaded function is called, one of the following cases occurs:

• Case 1: A direct match is found, and there is no confusion in calling the appropriate
overloaded function.
• Case 2: If a match is not found, a linker error will be generated. However, if a direct
match is not found, then, at first, the compiler will try to find a match through the type
conversion or type casting.
• Case 3: If an ambiguous match is found, that is, when the arguments match more than
one overloaded function, a compiler error will be generated. This usually happens because
all standard conversions are treated equal.
 Function Overloading
• Two or more functions can have the same name but different
parameters
• Example:
int max(int a, int b) float max(float a, float b)
{ {
if (a>= b) if (a>= b)
return a; return a;
else else
return b; return b;
} }
 Overloading Function Call Resolution
❑ Overloaded function call resolution is done by compiler during
compilation
– The function signature determines which definition is used
❑ a Function signature consists of:
– Parameter types and number of parameters supplied to a function
❑ a Function return type is not part of function signature and is not used in
function call resolution
Function overloading example: {
cout<<“\n sum of characters are”<<x+y;
void sum(int,int); }
void sum(double,double);
void sum(char,char);
void main() Output:
{ Sum of integers 30
int a=10,b=20 ;
double c=7.52,d=8.14; sum of two floating no are 15.66
char e=‘a’ , f=‘b’ ; sum of characters are 195
sum(a,b);
//calls sum(int x,int y)
sum(c,d);
alls sum (double x,double y)
sum(e,f);
// calls sum(char x,char y)
}
void sum(int x,int y)
{
vout<<“\n sum of integers are”<<x+y;
}
void sum(double x,double y){
cout<<“\n sum of two floating no are”<<x+y;
}
void sum(char x,char y)
Function overloading example:
#include<iostream>
Using namespace std;

void area(int x)
{ cout<<“area is”<<x*x;
}
void area(int x,int y)
{cout<<“area of rectang;e”=<<x*y;
}
void area(int x,int y,int z)
{cout<<“volume is”<<x*y*z;
}
int main(){
int side=10,le=5,br=6,a=4,b=5,c=6;
area(side);
area(le,br);
area(a,b,c);
return 0;}
 Function Selection Involves following Steps.
• Compiler first tries to find the Exact match in which the type of
argument are the same,and uses that func.
• If an exact match is not found,the compiler user the integral
promotions to the actual argument such as,char to int, float to
double.
• When either of them fails ,build in conversions are used(implicit
conversion) to the actual arguments and then uses the function
whose match is unique. But if there are multiple matches, then
compiler will generate an error message.
• For ex: long square(long n)
long square(double x)

• Now a func. call such as square(10) will cause

an error because int argument can be converted
into long also and double also.so it will show
ambiguity.

• User defined conversion are followed if all the

conversion are failed.
Overload Member function

Takes sample property as member

function.
Note : Need to be explained with all
function overloading concept.
 Methods that Cannot be Overloaded
1. Methods that differ only in the return type
2. Parameter declarations that differ only in a pointer * versus an array []
3. If paramters differ only in the prescence or absence of const and/or volatile
4. Using typedef does not introduce a new type, hence cannot be overloaded
5. Methods that differ only in their default arguments
6. Methods that differ only in a reference parameter and a normal parameter
 Method overloading- Points to Remember

1. There are multiple definitions for the same function name in the same scope
2. The definitions of these functions vary according to the types and/or the number of
arguments in the argument list
3. Data type of the return value is not considered while writing overloaded functions because
the appropriate function is called at the compile time while the return value will be
obtained only when the function is called and executed
 Try out Program

1/26/2023 Method Overloading 61

Questions
1. Which of the following permits function overloading on c++?
a) type
b) number of arguments
c) type & number of arguments
d) number of objects
2. Overloaded functions are ________________
a) Very long functions that can hardly run
b) One function containing another one or more functions inside it
c) Two or more functions with the same name but different number of parameters or type
d) Very long functions
3. What should be passed in parameters when function does not require any parameters?
a) void
b) blank space
c) both void & blank space
d) tab space

1/26/2023 Method Overloading 62

• The utility of operators such as +, =, *, /, >, <, and so on
is predefined in any programming language.
• Programmers can use them directly on built-in data types
to write their programs.
• However, these operators do not work for user-defined
types such as objects.
• Therefore, C++ allows programmers to redefine the
meaning of operators when they operate on class objects.
This feature is called operator overloading
Operator Overloading:
Operator – It is a symbol that indicates an operation.
Arithmetic operators are + (add two numbers), - (subtract two
numbers), * ( Multiply two numbers), / ( Divide between two
numbers).
At now, we will take an Addition ‘+’ Sign, its use of ‘+’ sign
is
5+5=10
2.5+2.5=5
❖ Operator Overloading means multiple functions or multiple
jobs. In operator overloading the ‘+’ sign use of add the two
objects.
❖ One of C++’s great features is its extensibility, Operator
Overloading is major functionality related to extensibility.
❖ In C++, most of operators can be overloaded so that they can
perform special operations relative to the classes you create.
❖ For Example, ‘+’ operator can be overloaded to perform an
operation of string concatenation along with its pre-defined
job of adding two numeric values.
❖ When an operator is overloaded, none of its original meaning
will be lost.
❖ After overloading the appropriate operators, you can use
C++’s built in data types.
Unary Operator
- Operators attached to a single operand.
(-a, +a, --a, ++a, a--, a++)
Binary Operator
- Operators attached to two operand.
(a-b, a+b, a*b, a/b, a%b, a>b, a<b )
return-type class-name:: operator op(arg-list)
{
function body
}
EXPLANATION
❖ return type – It is the type of value returned by the specified
operation.
❖ op - It is the operator being overloaded. It may be unary or
binary operator. It is preceded by the keyword operator.
❖ operator op - It is the function name, Where operator is a
keyword.
Introduction
One of the exciting features of C++
Works only on the single variable
It can be overloaded two ways
1. Static member function
2. Friend function
-,+,++,-- those are unary operator which we can
overloaded.
Using a member function to Overload Unary Operator
Using a Friend Function to Overload a Unary Operator
• The function will take one operand as an argument.
• This operand will be an object of the class.
• The function will use the private members of the class only with
the object name.
• The function may take the object by using value or by reference.
• The function may or may not return any value.
• The friend function does not have access to the this pointer.
Example:- Use of friend function to overload a unary operator
 Example Program:
Write a program which will convert an positive values in an object to negative value.
Code:
#include <iostream>
class demo
{
int x,y,z; public:
void getdata (int a, int b,int c)
{
x=a;
y=b; z=c;
}
void display();
void operator –();
};
void demo::display()
{
cout<<“x=“<<x<<“\ny=“<<y<<“\nz=“<<z<<endl;
}
void demo::operator –()
{
x=-x;
y=-y;
z=-z;
}
int main()
{
demo obj1;

CONTD...,
obj1.getdata(10,20,30);
obj1.display();
-obj1;
obj1.display();
return 0;
}
Output:
x=10
y=20
z=30

x=-10
y=-20
z=-30
INTRODUCTION
In Binary operator overloading function, there should be one
argument to be passed.
It is overloading of an operator operating on two operands.
#include<iostream>
class multiply
{
int first,second;
public:
void getdata(int a,int b)
{
first=a;
second=b;
}

Contd...,
void display()
{
cout<<“first=“<<first<<“second=“<<secon<<endl;
}
multiply operator *(multiply c);
};
void multiply::operator *(multiply c)
{
multiply temp;
temp.first=first*c.first;
temp.second=second*c.second;
return temp;
}

Contd..,
int main()
{
multiply obj1,obj2,obj3;
obj1.getdata(15,20);
obj2.getdata(3,45);
obj3=obj1*obj2;
obj3.display();
return 0;
}
Output:
45
900
 18CSC202J- Object Oriented
Design and Programming

Unit II

UML Sequence Diagram

1/26/2023 Sequence Diagram 82

Agenda :
1) To understand about interaction diagram
2) To draw sequence diagram using StarUML

1/26/2023 Sequence Diagram 83

 Interaction Diagram
• Interaction diagrams are used to observe the dynamic behavior of a
system.

• Interaction diagram visualizes the communication and sequence of

message passing in the system.

• Interaction diagram represents the structural aspects of various

objects in the system.

• Interaction diagram represents the ordered sequence of interactions

within a system.

• Interaction diagram provides the means of visualizing the real time

data via UML.

1/26/2023 Sequence Diagram 84

 • This interactive behavior is represented in UML by two
diagrams known as

• Sequence diagram
• Collaboration diagram.

• Sequence diagram emphasizes on time sequence of messages

from one object to another.

• Collaboration diagram emphasizes on the structural

organization of the objects that send and receive messages.

1/26/2023 Sequence Diagram 85

How to Draw an Interaction Diagram?
• The purpose of interaction diagrams is to capture the dynamic aspect of a
system.

• So to capture the dynamic aspect, we need to understand what a dynamic

aspect is and how it is visualized. Dynamic aspect can be defined as the
snapshot of the running system at a particular moment.

• Following things are to be identified clearly before drawing the interaction

diagram
• Objects taking part in the interaction.
• Message flows among the objects.
• The sequence in which the messages are flowing.
• Object organization.

1/26/2023 Sequence Diagram 86

 Sequence Diagram
• A sequence diagram simply depicts interaction between
objects in a sequential order i.e. the order in which these
interactions take place.

1/26/2023 Sequence Diagram 87

 Sequence Diagram Notations
Actors :
An actor in a UML diagram represents a type of role where it interacts with
the system and its objects.

1/26/2023 Sequence Diagram 88

 2.Lifelines :
➢A lifeline is a named element which depicts an individual participant in
a sequence diagram. So basically each instance in a sequence diagram
is represented by a lifeline.
➢ Lifeline elements are located at the top in a sequence diagram.
➢ lifeline follows the following format :
Instance Name : Class Name

1/26/2023 Sequence Diagram 89

3.Messages :

➢ Communication between objects is depicted using messages. The messages appear in a

sequential order on the lifeline.

➢We represent messages using arrows. Lifelines and messages form the core of a sequence
diagram.

1/26/2023 Sequence Diagram 90

 Synchronous messages
▪ A synchronous message waits for a reply before the interaction can move
forward.
▪ The sender waits until the receiver has completed the processing of the
message.
▪ The caller continues only when it knows that the receiver has processed
the previous message i.e. it receives a reply message.
▪ A large number of calls in object oriented programming are synchronous.
We use a solid arrow head to represent a synchronous message.

1/26/2023 Sequence Diagram 91

Asynchronous Messages

▪ An asynchronous message does not wait for a reply from the receiver.
▪ The interaction moves forward irrespective of the receiver processing the
previous message or not.
▪ We use a lined arrow head to represent an asynchronous message.

1/26/2023 Sequence Diagram 92

 Create message
▪ We use a Create message to instantiate a new object in the sequence
diagram.
▪ It is represented with a dotted arrow and create word labeled on it to
specify that it is the create Message symbol.
For example :
▪ The creation of a new order on a e-commerce website would require a
new object of Order class to be created.

1/26/2023 Sequence Diagram 93

 Delete Message
• We use a Delete Message to delete an object.
• It destroys the occurrence of the object in the system.
• It is represented by an arrow terminating with a x.
For example – In the scenario below when the order is received by the user,
the object of order class can be destroyed

1/26/2023 Sequence Diagram 94

Self Message

• A message an object sends to itself, usually shown as a U shaped arrow pointing

back to itself.

1/26/2023 Sequence Diagram 95

Reply Message

• Reply messages are used to show the message being sent from the receiver
to the sender.

• We represent a return/reply message using an open arrowhead with a

dotted line.

• The interaction moves forward only when a reply message is sent by the
receiver.

1/26/2023 Sequence Diagram 96

Found Message
• A Found message is used to represent a scenario where an unknown source
sends the message.
• It is represented using an arrow directed towards a lifeline from an end
point.

1/26/2023 Sequence Diagram 97

 Lost Message
• A Lost message is used to represent a scenario where the recipient is not
known to the system.
• It is represented using an arrow directed towards an end point from a
lifeline.
For example:

1/26/2023 Sequence Diagram 98

Example – Sequence Diagram

1/26/2023 Sequence Diagram 99

Questions
1. What does a message mean?
a) It Passes all communications from one object to another and are represented by message
arrows in sequence diagrams.
b) The message goes from the sending object’s lifeline to the receiving object’s lifeline.
c) It is a rectangle containing an identifier with a dashed line extending below the rectangle.
d) List of all attributes.
2. What is a lifeline?
a) It is a frame consisting of a rectangle with a pentagon in its upper left-hand corner
b) It is a rectangle containing an identifier with a dashed line extending below the rectangle
c) It is a name compartment; the interaction is represented inside the rectangle
d) Emergency situation in real world approach.

1/26/2023 Sequence Diagram 100