21CSC101T

Object Oriented Design and Programming

UNIT-1
Topic : PROCEDURAL AND OBJECT
ORIENTED PROGRAMMING
• The main program coordinates calls to procedures
and hands over appropriate data as parameters.
Procedure Oriented Programming Language
C function aspects Syntax

Function declaration Return-type function-name(argument list);

Eg : int add(int a, int b);

Function definition Return-type function-name(argument list)
{ body of function;)

Eg : int add(int a, int b)

{int c;
c=a+b;
Return c; }

Function call Function-name(argument list);

Eg : add(5,10);
Features of Procedure Oriented Programming
Language
• Smaller programs - A program in a procedural
language is a list of instructions.
• Larger programs are divided in to smaller programs
known as functions.
• Each function has a clearly defined purpose and a
clearly defined interface to the other functions in the
program.
• Data is Global and shared by almost all the functions.
• Employs Top Down approach in Program Design.
 Examples of Procedure Oriented
Programming Language

• COBOL
• FORTRAN
•C
 Sample COBOL Program(Procedure Oriented)

IDENTIFICATION DIVISION.
PROGRAM-ID.

ENVIRONMENT DIVISION. * procedure will be followed by using few Division

DATA DIVISION.
WORKING-STORAGE SECTION.
77 A PIC 9999.
77 B PIC 9999.
77 ANS PIC 999V99.

PROCEDURE DIVISION.
MAIN-PARA.
DISPLAY \”--------------------------------\”.
DISPLAY \” ENTER A\”
ACCEPT A. * command line argument
DISPLAY \”ENTER B\”.
ACCEPT B.
DISPLAY \”----------------------------------\”.

ADD-PARA.
ADD A B GIVING ANS.
DISPLAY \”-------------------------------------\”.
DISP-PARA.
DISPLAY \”A IS \” A.
DISPLAY \”B IS \” B.
DISPLAY \”ADDITION -\” ANS.
STOP RUN. * to stop the program
 Disadvantages of Procedural
Programming Language
Unrestricted access
• functions have unrestricted access to global data.
Real-world modeling
• unrelated (separated) functions and data, the basis
of the procedural paradigm, provide a poor model
of the real world.
• Complex real-world objects have both attributes
(data) and behavior (function).
 Object-Oriented Concept

• Objects of the program interact by sending messages to each

other, hence it increases the data security (data can be accessed
only through its instances)
 Object Oriented Programming
• Object-oriented programming is a programming paradigm that uses
abstraction in the form of classes and objects to create models based on
the real world environment.

• An object-oriented application uses a collection of objects, which

communicate by passing messages to request services.

• The aim of object-oriented programming is to try to increase the

flexibility and maintainability of programs.

• Because programs created using an OO language are modular, they can

be easier to develop, and simpler to understand after development
 Object-Oriented Concepts
• Everything is an object and each object has its own memory

• Computation is performed by objects communicating with each other

• Every object is an instance of a class. A class simply represents a grouping of

similar objects, such as Integers or lists.

• The class is the repository for behavior associated with an object. That is, that
all objects that are instances of the same class can perform the same actions.

• Classes are organized into a singly rooted tree structure, called the inheritance
hierarchy.
• Memory and behavior associated with instances of a class are automatically
available to any class associated with a descendant in this tree structure.
 Object-Oriented Programming vs.
Procedural Programming
• Programs are made up of modules, which are parts of a program that can
be coded and tested separately, and then assembled to form a complete
program.

• In procedural languages (i.e. C) these modules are procedures, where a

procedure is a sequence of statements.

• The design method used in procedural programming is called Top Down

Design.

• This is where you start with a problem (procedure) and then systematically
break the problem down into sub problems (sub procedures).
 Object-Oriented Programming vs.
Procedural Programming

• The difficulties with Procedural Programming, is that software

maintenance can be difficult and time consuming.
• When changes are made to the main procedure (top), those changes
can cascade to the sub procedures of main, and the sub-sub
procedures and so on, where the change may impact all procedures
in the pyramid.

• Object oriented programming is meant to address the difficulties

with procedural programming.
The main difference
 Comparison

Procedural Oriented Object Oriented

Program is divided into small parts Program is divided into small parts
called ‘Functions’ called ‘Objects’

Has access specifiers : Public,

Global and Local data
Private, Protected

Doesn’t have any proper way for

Provides data hiding and security
hiding data

Eg: C, VB, FORTAN Eg: C++, JAVA, VB.NET

Comparison
History of
C++
 class GasMolecule

Object-oriented programming • Data:

• molecular weight, structure, common
names, etc.
seeks to define a
Object-oriented programming (OOP) • Methods:
program in terms of the things in the • IR(wavenumStart, wavenumEnd) :
return IR emission spectrum in range
problem (files, molecules, buildings, cars,
people, etc.), what they need, and what they
can do. Objects (instances of a class)

GasMolecule ch4
GasMolecule co2 “pseudo-code”

spectrum = ch4.IR(1000,3500)
Name = co2.common_name
 “Actually I made up the term ‘object-oriented’, and I can tell you I did
Characteristics of C++ not have C++ in mind.”
– Alan Kay (helped invent OO programming, the Smalltalk language, and the GUI)

C++ is…
Compiled.
A separate program, the compiler, is used to turn C++ source code into a form directly executed by
the CPU.
Strongly typed and unsafe
Conversions between variable types must be made by the programmer (strong typing) but can be
circumvented when needed (unsafe)
C compatible
call C libraries directly and C code is nearly 100% valid C++ code.
Capable of very high performance
The programmer has a very large amount of control over the program execution
Object oriented
With support for many programming styles (procedural, functional, etc.)
No automatic memory management
The programmer is in control of memory usage
 “If you’re not at all interested in performance,

When to choose C++ shouldn’t you be in the Python room down the hall?”
― Scott Meyers (author of Effective Modern C++)

Despite its many competitors C++ has Choose C++ when:

remained popular for ~30 years and will Program performance matters
continue to be so in the foreseeable future. Dealing with large amounts of data,
multiple CPUs, complex algorithms, etc.
Why?
Programmer productivity is less important
Complex problems and programs can be It is faster to produce working code in
effectively implemented Python, R, Matlab or other scripting
OOP works in the real world! languages!
No other language quite matches C++’s The programming language itself can help
combination of performance, organize your code
expressiveness, and ability to handle Ex. In C++ your objects can closely model
complex programs. elements of your problem
Access to libraries
Ex. Nvidia’s CUDA Thrust library for GPUs
Your group uses it already!
Behind the Scenes: The Compilation Process
 Topics covered
• I/O Operation
• Data types
• Variable
• Static
• Constant
• Pointer
• Type conversion
 I/O Operation

• C++ I/O operation occurs in streams, which involve transfer of

information into byte
• It’s a sequences of bytes
• Stream involved in two ways
• It is the source as well as the destination of data
• C++ programs input data and output data from a stream.
• Streams are related with a physical device such as the monitor
or with a file stored on the secondary memory.
• In a text stream, the sequence of characters is divided into lines,
with each line being terminated.
• With a new-line character (\n) . On the other hand, a binary
stream contains data values using their memory representation.
 Stream in C

Text Stream Binary Stream

 Cascading of Input or Output Operators

• << operator –It can use multiple times in the

same line.
• Its called Cascading
• Cout ,Cin can cascaded

• For example
• cout<<“\n Enter the Marks”;
• cin>> ComputerNetworks>>OODP;
 Reading and Writing Characters and Strings
• char marks;
• cin.get(marks);//The value for marks is read
• OR
• marks=cin.get();//A character is read and assigned to
marks
• string name;
• Cin>>name;

• string empname;
• cin.getline(empname,20);
• Cout<<“\n Welcome ,”<<empname;
Formatted Input and Output Operations

Formatted I/O

I/O class function Manipulators

and flages
#include<iostream.h>
#define PI 3.14159
main()
{
cout.precision(3);
cout.width(10);
cout.fill(‘*’);
cout<<PI;
Output
*****3.142
 Formatting with flags

• The setf() is a member function of the ios class that is

used to set flags for formatting output.
• syntax -cout.setf(flag, bit-field)
• Here, flag defined in the ios class specifies how the
output should be formatted
• bit-field is a constant (defined in ios ) that identifies
the group to which the formatting flag belongs to.
• There are two types of setf()—one that takes both flag
and bit-fields and the other that takes only the flag .
 Formatting Output Using Manipulators
• C++ has a header file iomanip.h that contains
certain manipulators to format the output
Data Types in C++
 Variables

A variable is the content of a memory location that stores a certain value. A variable is identified or denoted by a variable
name. The variable name is a sequence of one or more letters, digits or underscore, for example: character_
Rules for defining variable name:
❖ A variable name can have one or more letters or digits or underscore for example character_.
❖ White space, punctuation symbols or other characters are not permitted to denote variable name.
❖ A variable name must begin with a letter.
❖ Variable names cannot be keywords or any reserved words of the C++ programming language.
❖ Data C++ is a case-sensitive language. Variable names written in capital letters differ from variable names with the same
name but written in small letters.

01 Local Variables 03 Instance variables

02 Static Variables 04 Final Variables

 Variables

Local Variables Instance Variables Static Variables Constant Variables

Local variable: These are the Instance variable: These are

Static variables: Static Constant is something that
variables which are declared the variables which
variables are also called as doesn't change. In C
within the method of a class. are declared in a class but
class variables. These language and C++ we use
outside a method,
variables have only one copy the keyword const to make
Example: constructor or any block.
that is shared by all the program elements
public class Car { Example:
different objects in a class. constant.
public: public class Car {
Example: Example:
void display(int m){ // private: String color;
public class Car { const int i = 10;
Method // Created an instance
public static int tyres; void f(const int i)
int model=m; variable color
// Created a class variable class Test
// Created a local variable Car(String c)
void init(){ {
model {
tyres=4; const int i;
cout<<model; color=c;
}} };
} }}
 CONSTANTS
• Constants are identifiers whose value does not change. While variables
can change their value at any time, constants can never change their
value.
• Constants are used to define fixed values such as Pi or the charge on an
electron so that their value does not get changed in the program even by
mistake.
• A constant is an explicit data value specified by the programmer.
• The value of the constant is known to the compiler at the compile time.
 Declaring Constants
• Rule 1 Constant names are usually written in capital letters to
visually distinguish them from other variable names which
are normally written in lower case characters.
• Rule 2 No blank spaces are permitted in between the #
symbol and define keyword.
• Rule 3 Blank space must be used between #define and
constant name and between constant name and constant
value.
• Rule 4 #define is a preprocessor compiler directive and not a
statement. Therefore, it does not end with a semi-colon.
 Special Operators

Scope resolution operator

In C, the global version of a variable cannot be accessed from within the inner block. C++ resolves this
1
problem by using scope resolution operator (::), because this operator allows access to the global version of
a variable. New Operator

2 The new operator denotes a request for memory allocation on the Heap. If sufficient memory is available, new
operator initializes the memory and returns the address of the newly allocated and initialized memory to the
Delete Operator
pointer variable.
3 Since it is programmer’s responsibility to deallocate dynamically allocated memory, programmers are provided
.
delete operator by C++ language Member Operator

4 C++ permits us to define a class containing various types of data & functions as members. To access a
member using a pointer in the object & a pointer to the member.
Operator Precedence
Rank Operators Associativity
1 ++, --, +, -, !(logical complement) ,~(bitwise complement) ,(cast) Right
2 *(mul) , /(div), %(mod) Left
3 + , - (Binary) Left
4 >> , <<, >>> (Shift operator) Left
5 >, <, >=,<= Left
6 ==, != Left
7 & (Bitwise and) Left
8 ^ ( XOR) Left
9 | (Bitwise OR) Left
10 && (Logical and) Left
11 || (Logical OR) Left
12 Conditional Right
13 Shorthand Assignment Right
Pointers
 Introduction

• Pointers are symbolic representation of addresses.

• They enable programs to simulate call-by-reference as well as to create and manipulate
dynamic data structures.
• Syntax data_type *pointer_variable;
• Example
int *p,sum;
Assignment
• integer type pointer can hold the address of another int variable
• To assign the address of variable to pointer-ampersand symbol (&)
• p=&sum;
this pointer
hold the adderss of current object
• int num;
• This->num=num;

Void?
• When used in the declaration of a pointer, void specifies that the pointer is
"universal." If a pointer's type is void* , the pointer can point to any variable that's not
declared with the const or volatile keyword.
Real Time Example
 How to use it
• P=&sum;//assign address of another variable
• cout<<&sum; //to print the address of variable
• cout<<p;//print the value of variable
• Example of pointer
#include<iostream.h>
using namespace std;
int main()
{ int *p,sum=10;
p=&sum;
cout<<“Address of sum:”<<&sum<<endl;
cout<<“Address of sum:”<<p<<endl; Output:
Address of sum : 0X77712
cou<<“Address of p:”<<&p<<endl;
Address of sum: 0x77712
cout<<“Value of sum”<<*p; Address of p: 0x77717
} Value of sum: 10
 Pointers and Arrays
• assigning the address of array to pointer don’t
use ampersand sign(&)
#include <iostream>
using namespace std;
int main(){
//Pointer declaration
int *p; OUTPUT:
//Array declaration 0
1
int arr[]={1, 2, 3, 4, 5, 6}; 2
//Assignment 3
p = arr; 4
5
for(int i=0; i<6;i++){ 6
cout<<*p<<endl;
//++ moves the pointer to next int position
p++;
}
return 0;
}
 This Pointers
• this pointer hold the address of current
object
• int num;
• This->num=num;
 This pointer Example
101 Sonoo 890000 102 Nakul 59000
101 Sonoo 890000 102 Nakul 59000
101 Sonoo 890000 102 Nakul 59000
101 Sonoo 890000

#include <iostream>
using namespace std;
class Employee {
public:
int id; //data member (also instance variable)
string name; //data member(also instance variable)
float salary;
Employee(int id, string name, float salary) Output: 101 Sonoo 890000
{
this->id = id; 102 Nakul 59000
this->name = name;
this->salary = salary;
}
void display() {
cout<<id<<" "<<name<<" "<<salary<<endl;
} };
int main(void) {
Employee e1 =Employee(101, "Sonoo", 890000); //creating an object of Employee
Employee e2=Employee(102, "Nakul", 59000); //creating an object of Employee
e1.display(); e2.display(); return 0; }
 Function using pointers
#include<iostream> void swap(int *a,int *b)
using namespace std; {
void swap(int *a ,int *b ); int c;
//Call By Reference c=*a;
int main() *a=*b;
{ *b=c;
int p,q; }
cout<<"\nEnter Two Number You Want To
Output:
Swap \n";
Enter Two Number You Want to
cin>>p>>q; Swap
swap(&p,&q); 10 20
cout<<"\nAfter Swapping Numbers Are Given After Swapping Numbers Are
below\n\n"; Given below
cout<<p<<" "<<q<<" \n"; 20 10
return 0;
}
 MCQ

What will happen in the following C++ code snippet?

1)Int a=100, b=200;
2) Int *p=&a, *q=&b;
3) p=q;
Choose the correct one.

a) b is assigned to a
b) p now points to b
c) a is assigned to b
d) q now points to a
 MCQ - Answer

a) b is assigned to a
b) p now points to b
c) a is assigned to b
d) q now points to a
 MCQ-What is output of the following code?
#include <iostream>
using namespace std;
int main()
{
char arr[20];
int i;
for(i = 0; i < 10; i++)
*(arr + i) = 65 + i;
*(arr + i) = '\0';
cout << arr;
return(0);
}
 MCQ - Answer

• Answer: ABCDEFGHIJ
Explanation: Each time we are assigning 65 +
i.
• In first iteration i = 0 and 65 is assigned.
• So it will print from A to J.
 Type conversion and type casting
• Type conversion or typecasting of variables refers to changing a variable of one
data type into another.
• While type conversion is done implicitly, casting has to be done explicitly by the
programmer.
 Implicit Type Conversion
The type conversion that is done automatically done by the compiler is known
as implicit type conversion. This type of conversion is also known as automatic
conversion.

#include <iostream>
using namespace std;
int main()
{
int x = 10;
// integer x
char y = 'a’;
// character y implicitly converted to int. ASCII
// value of 'a' is 97
x = x + y;
// x is implicitly converted to float
int z = x + 1;
cout << "x = " << x << endl<< "y = " << y << endl<< "z = " << z << endl;
return 0;}
 Type Casting

• Type casting an arithmetic expression tells the compiler to

represent the value of the expression in a certain format.
• It is done when the value of a higher data type has to be converted
into the value of a lower data type.
• However, this cast is under the programmer’s control and not
under the compiler’s control.
• Syntax:
• destination_variable_name=destination_data_type(source_variable
_name);

float sal=10000.00;
int income;
Income=int(sal);
 Example for Explicit Type Conversion

#include <iostream>
using namespace std;
int main()
{ double x = 1.2;
// Explicit conversion from double to int
int sum = (int)x + 1;
cout << "Sum = " << sum;
return 0;}
Output:
Sum = 2
Class and objects - Features
 Class

• Class is a user defined data type, defined using keywork class.

• It holds its own data members and member functions,
• It can be accessed and used by creating instance of that class.
• The variables inside class definition are called as data members and
the functions are called member functions

class className
{
data members
member functions
};
• Class is just a blue print, which declares and
Example
defines characteristics and behavior, namely class Room {
public:
data members and member functions
double length;
respectively. double breadth;
double height;
• All objects of this class will share these
characteristics and behavior. double calculateArea(){
return length * breadth;
• Class name must start with an uppercase
}
letter(Although this is not mandatory).
double calculateVolume(){
Example,
return length * breadth * height;
class Student }

};
Define a Class Type
- Data members Can be of any type, built-in or
user-defined.
This may be,
• non-static data member
Each class object has its own copy

• static data member

Acts as a global variable
• Static data member is declared using the static keyword.
• There is only one copy of the static data member in the class. All the
objects share the static data member.
• The static data member is always initialized to zero when the first class
object is created.

Syntax:
static data_type datamember_name;
Here
static is the keyword.
data_type – int , float etc…
datamember_name – user defined
 Static Data Member
Rectangle r1;
class Rectangle Rectangle r2;
{ Rectangle r3;
private:
int width;
int length; count

static int count;

r1 r2
public: width width
void set(int w, int length length

l); width
int area(); r3 length

}
 Member Functions
• Used to
– access the values of the data members (accessor)
– perform operations on the data members
(implementor)
• Are declared inside the class body
• Their definition can be placed inside the class
body, or outside the class body
• Can access both public and private members of
the class
• Can be referred to using dot or arrow member
access operator
 Member function
keyword Class Name
class Rectangle
{ int main()
private: {
int width, length; Rectangle r2; Object creation
public: r1.set(5,8); Inside the
void set (int w, int l); int x=r1.area(); function
member
int area() cout<<"x value in r1 "<<x;
function
{ r2.set(5,8);
inside the class return width*length; int x=r1.area();
} class name cout<<"x value in r2 "<<x;
}r1,; Member function
Object void Rectangle :: set (int w, int l) }
creation {
outside the class
width = w;
length = l;
}
scope operator
const member function

• The const member functions are the functions which are declared as constant in the program.
• The object called by these functions cannot be modified.
• It is recommended to use const keyword so that accidental changes to object are avoided.
• A const member function can be called by any type of object.
• Note: Non-const functions can be called by non-const objects only.

Syntax: User defined

keyword
datatype function_name const();
 Const Member Function
class Time
{
private : function declaration
int hrs, mins, secs ;

public :
void Write ( )
function definition
const ;
};

void Time :: Write( ) const

{
cout <<hrs << “:” << mins << “:” << secs << endl;
}
 What is an object?

OBJECT
set of methods
Operations (member functions)

Data internal state

(values of private data members)
Object:
• Objects are instances of class, which holds the data variables declared in
class and the member functions work on these class objects.
• Each object has different data variables.
• Objects are initialized using special class functions called Constructors.
• Destructor is special class member function, to release the memory reserved
by the object.

Syntax of creating object :

Class_name object_name;
 Declaration of an Object

class Rectangle
main()
{ {
private: Rectangle r1;
Rectangle r2;
int width;
int length; r1.set(5, 8);
public: cout<<r1.area()<<endl;

void set(int w, int r2.set(8,10);

l); cout<<r2.area()<<endl;
int area(); }

};
 Another Example

#include <iostream.h> // member function definitions

void circle::store(double r)
class circle {
{ radius = r;
private: }
double radius; double circle::area(void)
{
public: return 3.14*radius*radius;
void store(double); }
double area(void); void circle::display(void)
void display(void); {
cout << “r = “ << radius <<
}; endl;
}
int main(void) {
circle c; // an object of circle class
c.store(5.0);
cout << "The area of circle c is " << c.area() << endl;
c.display();
}
 Declaration of an Object
r1 is statically allocated
class Rectangle
{ main()
private: {
Rectangle r1;
int width;
r1.set(5, 8);
int length;
}
public:
void set(int w, int
r1
l); width = 5
length = 8
int area();
};
 Declaration of an Object
r2 is a pointer to a Rectangle object
class Rectangle
{ main()
{
private: Rectangle r1;
int width; r1.set(5, 8); //dot notation

int length; Rectangle *r2;

r2 = &r1;
public: r2->set(8,10); //arrow notation
void set(int w, int }

l); 5000
r1 r
int area(); width = 8
5 2
6000
length = 10
8 5000
???
};
 Object Initialization
1. By Assignment

#include <iostream.h>
• Only work for public data
members
class circle
{ • No control over the operations
public: on data members
double radius;
};
int main()
{
circle c1; // Declare an instance of the class circle
c1.radius = 5; // Initialize by assignment

}
 Object Initialization
2. By Public Member Functions

#include <iostream.h>
class circle
{
private:
double radius;
public:
void set (double r)
{radius = r;}
double get_r ()
{return radius;}
};

int main(void) {
circle c; // an object of circle class
c.set(5.0); // initialize an object with a public member function
cout << "The radius of circle c is " << c.get_r() << endl;
// access a private data member with an accessor
}
Declaration & Initialization of an Object

#include <iostream.h>
• Only work for public data
members
class circle
{ • No control over the operations
public: on data members
double radius;
};
int main()
{
circle c1; // Declare an instance of the class circle
c1.radius = 5; // Initialize by assignment

}
 Examples

class Rectangle
main()
{ {
private: Rectangle r1;
int width; Rectangle r2;
int length; r1.set(5, 8);
public: cout<<r1.area()<<endl;
void set(int w, int l);
r2.set(8,10);
int area(); cout<<r2.area()<<endl;
}; }
 Example: 2

// Program to illustrate the working of

// objects and class in C++ Programming

#include <iostream>
using namespace std;

// create a class
class Room {

public:
double length;
double breadth;
double height;

double calculateArea() {
return length * breadth;
}

double calculateVolume() {
return length * breadth * height;
}
};
 Sample Exercises

1) Find whether the student is eligible for the current year placement from the
inputs student name, CGPA, gender (M/F), number of backlogs.
Implement the above by using object oriented programming concept.

2)Employee payroll system contains the fileds Employee name,Employee

ID,Basic pay,HRA,TA,,DA,Grade pay and Deduction 5% from Basic pay.Find
the Gross pay, Net pay (Grade pay + deductions) and print all the details given
above, using class and object of get () method and cal( )method.

3)Write a program that would print the information (name, year of joining,
salary, address) of three employees by creating a class named
&#39;Employee&#39;. The output should be as follows:
Name Year of joining Address
Robert 1994 64C- WallsStreat
Sam 2000 68D- WallsStreat
John 1999 26B- WallsStreat
Feature : Objects and Classes
 Objects and Classes
•Class is a user defined data type, which holds its own data
members and member functions, which can be accessed and
used by creating instance of that class.

–Attributes – member of a class.

•An attribute is the data defined in a class that maintains the
current state of an object. The state of an object is determined
by the current contents of all the attributes.

–Methods – member functions of a class

 Objects and classes
• A class itself does not exist; it is merely a description of an
object.
• A class can be considered a template for the creation of object

• Blueprint of a building class

• Building object

• An object exists and is definable.

• An object exhibits behavior, maintains state, and has traits. An
object can be manipulated.
• An object is an instance of a class.
 Methods
• A method is a function that is part of the class definition. The methods of a
class specify how its objects will respond to any particular message.

• A method is a collection of statements that perform some specific task and

return the result to the caller. A method can perform some specific task
without returning anything.

• Methods allow us to reuse the code without retyping the code.

• A message is a request, sent to an object, that activates a method (i.e., a

member function).
Defining a Base Class - Example
•A base class is not defined on, nor does it inherit members from, any
other class.

#include <iostream>
using std::cout; //this example “uses” only the necessary
using std::endl; // objects, not the entire std namespace

class Fraction {
public:
void assign (int, int); //member functions
double convert();
void invert();
void print();
private:
int num, den; //member data
};
Continued…
Using objects of a Class - Example
The main() function:

int main()
{
Fraction x;
x.assign (22, 7);
cout << "x = "; x.print();
cout << " = " << x.convert() << endl;
x.invert();
cout << "1/x = "; x.print(); cout << endl;
return 0;
}

Continued…
 Defining a Class – Example
Class Implementation:
void Fraction::assign (int numerator, int denominator)
{
num = numerator;
den = denominator;
}
double Fraction::convert ()
{
return double (num)/(den);
}
void Fraction::invert()
{
int temp = num;
num = den;
den = temp;
}
void Fraction::print()
{
cout << num << '/' <
}< den;
 Difference Between Class and Structure

S.No Class Structure

1 Members of a class are private Members of a structure are public
by default. by default.
2 Member classes/structures of a Member classes/structures of a
class are private by default. structure are public by default.
3 It is normally used for data It is normally used for the grouping
abstraction and further of data
inheritance.
4 Security is high here. Less Security.
5 It is declared using It is declared using
the class keyword. the struct keyword.
 Debug the code
/*Beginning of structDistance02.cpp*/
#include <iostream.h>
struct Distance {
private: int iFeet; float fInches;
public: void setFeet(int x) {
iFeet=x; //????? Legal or not
int getFeet()
{ return iFeet; }
void setInches(float y) {
fInches=y; }
float getInches() {
return fInches; } };
 Debug the code

void main() {
Distance d1,d2;
d1.setFeet(2);
d1.setInches(2.2);
d2.setFeet(3);
d2.setInches(3.3);
d1.iFeet++; // ??????
cout<<d1.getFeet()<<d1.getInches()<<d2.getFeet()<<d2.getInche
s()<<endl;
 Scope Resolution Operator

• It is possible and usually necessary for the library

programmer to define the member functions
outside their respective classes.
• The scope resolution operator makes this
possible.
• Program illustrates the use of the scope resolution
operator (::)
 Scope Resolution Operator Example
/*Beginning of scopeResolution.cpp*/
class Distance
{
int iFeet;
float fInches;
public:
void setFeet(int); //prototype only
int getFeet(); //prototype only
void setInches(float); //prototype only
float getInches(); //prototype only
};
void Distance::setFeet(int x) //definition { iFeet=x; }
int Distance::getFeet() //definition { return iFeet; }
void Distance::setInches(float y) //definition { fInches=y; }
float Distance::getInches() //definition{return fInches;}
/*End of scopeResolution.cpp*/
Topic : UML Class Diagram, its components,
Class Diagram relations and Multiplicity
 A Recap……void Fraction::assign (int
numerator, int denominator)
{
#include <iostream> num = numerator;
using namespace std; den = denominator;
} int main()
double Fraction::convert () {
class Fraction { { Fraction x;
public: return double
void assign (int, x.assign (22, 7);
(num)/(den);
int); } cout << "x = "; x.print();
double convert(); cout << " = " << x.convert() << endl;
void invert(); void Fraction::invert() x.invert();
void print(); { cout << "1/x = "; x.print(); cout <<
private: int temp = num;
num = den; endl;
int num, den;
};
den = temp; return 0;
} }
void Fraction::print()
{
cout << num << '/' <<
den;
}
 UML Diagrams - Introduction

•UML stands for Unified Modeling Language

•It is a modern approach to modeling and documenting software
•It is one of the most popular business process modeling techniques
•It is based on diagrammatic representations of software components
•An old proverb says, “A picture is worth a thousand words”
•By using visual representations, we are able to better understand possible
flaws or errors in software or business processes
UML Diagrams - Introduction
SKETCH
•In this case, UML diagrams are only a lop-level view of the system
•It may not include all the necessary details to execute the project
•Forward Design:
•The design of the sketch is done before coding the application
•We can get a better view of the system or workflow that we are trying to create
•Many design issues or flaws can be revealed
•The overall project health and well-being can be improved
•Backward Design:
•After writing the code, the UML diagrams are drawn as a form of documentation
UML Diagrams - Introduction
BLUEPRINT
•In this case, the UML diagram serves as a complete design that requires the
actual implementation of the system or software.
•Often, this is done by using CASE tools (Computer Aided Software Engineering
Tools)
•It needs more expertise and user training
 Overview of UML Diagrams
Behavioral
: behavioral features of a system / business process
Structural
: element of spec. irrespective of time • Activity
• State machine
• Class • Use case
• Component • Interaction
• Deployment
• Object
• Composite structure Interaction
• Package : emphasize object interaction

• Communication(collaberation
)
• Sequence
• Interaction overview
• Timing
 Class Diagram

•It is the most common diagram type for software documentation

•Class diagrams contain classes with their attributes (data members) and their
behaviours (member functions)
ClassName
•Each class has 3 fields:
Attributes
•Class Name
•Attributes Behaviours
•Behaviours
•The relation between different classes makes up
a class diagram
Class Attributes
Person

name : String An attribute is a named property of a

address : Address class that describes the object being modeled.
birthdate : Date In the class diagram, attributes appear in
ssn : Id the second compartment just below the
name-compartment.
Class Attributes (Cont’d)
Attributes are usually listed in the form:
Person
+ name : String attributeName : Type
# address :
Address Attributes can be:
# birthdate : Date + public
/ age : Date # protected
- ssn : Id - private
/ derived
Class Attributes (Cont’d)
A derived attribute is one that can be
Person computed from other attributes, but
doesn’t actually exist. For example,
name : String a Person’s age can be computed from
address : Address his birth date. A derived attribute is
birthdate : Date designated by a preceding ‘/’ as in:
/ age : Date
ssn : Id / age : Date
Class Operations
Person
name : String
address :
Address
birthdate : Date
ssn : Id
eat Operations describe the class behavior
sleep and appear in the third compartment.
work
play
Class Operations (Cont’d)
PhoneBook

newEntry (n : Name, a : Address, p : PhoneNumber, d :

Description)
getPhone ( n : Name, a : Address) : PhoneNumber

You can specify an operation by stating its signature: listing the

name, type, and default value of all parameters, and, in the case of
functions, a return type.
Depicting Classes
When drawing a class, you needn’t show attributes and operation
in every diagram.

Person Person Person

name : String
birthdate : Date
Person ssn : Id
name Person eat()
address sleep()
birthdate eat work()
play play()
Class Responsibilities
A class may also include its responsibilities in a class diagram.

A responsibility is a contract or obligation of a class to perform

a particular service.

SmokeAlarm

Responsibilities

-- sound alert and notify guard station

when smoke is detected.

-- indicate battery state

Basic components of a class diagram

The standard class diagram is composed of three sections:

Upper section: Contains the name of the class. This section is
always required, to know whether it represents the classifier or
an object.
Middle section: Contains the attributes of the class. Use this
section to describe the qualities of the class. This is only
required when describing a specific instance of a class.
Bottom section: Includes class operations (methods).
Displayed in list format, each operation takes up its own line.
The operations describe how a class interacts with data.
 RULES TO BE FOLLOWED:
•Class name must be unique to its enclosing namespace.
•The class name begins in uppercase and the space between
multiple words is omitted.
•The first letter of the attribute and operation names is lowercase
with subsequent words starting in uppercase and spaces are
omitted.
• Since the class is the namespace for its attributes and
operations an attribute name must be unambiguous in the
context of the class.
Class Diagram
•Basic Components of a Class Diagram
•Upper Section
It contains the name of the class
•Middle Section
It contains the attributes of the class
•Bottom Section
It includes methods
•Let us model a Zoo System
•What’s in a Zoo? Animals
•Let us name the class Animal
•If our class is Animal, an instance of that class would
be a specific animal
Class Diagram – cont..
Attributes : Second Section
• How would you identify each instance of
that class, i.e., a specific animal?
• Using Attributes
• What are Attributes?
• A significant piece of data containing values that describe each instance of that class
• They are also known as fields, variables or properties
• Format for specifying an attribute:
visibility attributeName : Type [multiplicity] = DefaultValue {property string}
• Visibility: It sets the accessibility of an attribute / method
• Private (-) Visible only to the elements within the same class
• Public (+) Visible to any element that can see the class
• Protected (#) Visible to the elements in the class and its sub class
• Package (~) Visible to elements within the same package
Class Diagram – cont..
• Methods : Third section
• They are also known as operations or functions
• It specifies the behaviour of a class
• Eg: We may want to change the name of an Animal
• We could add a method setName
• We could also create a method for eating, since all of
our animals eat
• Lets take another example : Employee Details
Multiplicity and Relationships
Relationships
 Association
• An association is a relationship between two separate
classes. It joins two entirely separate entities.
• There are four different types of association:
– Bi-directional
– Uni-directional
– Aggregation (includes composition aggregation)
– Reflexive.
• Bi-directional and uni-directional associations are the
most common ones.
• This can be specified using multiplicity (one to one, one
to many, many to many, etc.).
• A typical implementation in Java is through the use of
an instance field. The relationship can be bi-directional
with each class holding a reference to the other.
 Inheritance
• Indicates that child (subclass) is considered to be a
specialized form of the parent (super class).
• For example consider the following:
 Example

• Above we have an animal parent class with all

public member fields.
• You can see the arrows originating from the duck,
fish, and zebra child classes which indicate they
inherit all the members from the animal class.
• Not only that, but they also implement their own
unique member fields.
• You can see that the duck class has a swim()
method as well as a quack() method.
 Interface
• A relationship between two model elements, in
which one model element implements/executes the
behavior that the other model element specifies.
Relationships b/w Classes
Dependency Relationships
A dependency indicates a semantic relationship between two or
more elements. The dependency from CourseSchedule to
Course exists because Course is used in both the add and
remove operations of CourseSchedule.

CourseSchedule
Course
add(c : Course)
remove(c :
Course)
 Dependency - Aggregation

• A special form of association which is a

unidirectional (a.k.a one way) relationship between
classes.
• The best way to understand this relationship is to
call it a “has a” or “is part of” relationship.
• For example, consider the two classes: Wallet and
Money.
• A wallet “has” money. But money doesn’t
necessarily need to have a wallet so it’s a one
directional relationship.
Relationships b/w Classes
Generalization Relationships
Person
A generalization connects a subclass
to its superclass. It denotes an
inheritance of attributes and behavior
from the superclass to the subclass and
indicates a specialization in the subclass
of the more general superclass.
Student
Generalization Relationships (Cont’d)
UML permits a class to inherit from multiple superclasses,
although some programming languages (e.g., Java) do not permit
multiple inheritance.

Student Employee

TeachingAssistant
Generalization Relationships
Multilevel Inheritance
(Cont’d)
Relationships b/w Classes
Inheritance (Generalization)
• Lets say in our zoo, the only animals we have are tortoises, otters and Slow Loris
• We make 3 new classes: Tortoise, Otter and
Slow Loris
• These subclasses inherit all the attributes and
methods of the superclass
• We could add an attribute specific to Otter
in the Otter class
• The main advantage of inheritance is that
if we wanted to change or add an attribute
for all animals, we need not make change in
every sub class
• We just make the change to the base class ‘Animal’ class and it applies across all sub classes
Relationships b/w Classes
Abstraction
• In this example ‘Animal’ is the Abstract Class
• We will create instance for only the subclasses
• We wouldn’t instantiate the Animal class itself
• The Animal class is just a way to simplify things and keep the code “dry”
• To show that it is an Abstract class, we can write the name of the class in italics Animal or we
can enclose it like <<Animal>>
Relationships b/w Classes
Association
• If we had a class for Sea Urchin
we could draw an association
• Sea otter is a marine mammal in
the north Pacific Ocean
• They eat mostly hard-shelled invertebrates
including sea urchins.

ASSOCI
ATION
Aggregation ( (open diamond)
• It is a special type of association that specifies a whole and its parts, where a part can exist
outside the whose
• Lets take a group of tortoises, called creep

• Any of our zoo’s tortoises could be part of a

creep

ASSOCIATION
A tortoise could leave the creep at any point and still
Exist on its own
An aggregation specifies a whole-part relationship between an
aggregate (a whole) and a constituent part, where the part can
exist independently from the aggregate. Aggregations are
denoted by a hollow-diamond adornment on the association.

Engine
Car
Transmission
Composition
• It is a special type of association that specifies a whole and its parts, where the part cannot
exist outside the whole
• Example: Let us say we have several different visitors centers in our zoo. And each of those
visitor centers has a lobby and a bathroom
• Now if one of our visitors centers was torn down, the lobby and the bathroom of that visitor
center are torn down as well.
• Composition : A child object cannot exist without its parent object
A composition indicates a strong ownership and coincident
lifetime of parts by the whole (i.e., they live and die as a
whole). Compositions are denoted by a filled-diamond
adornment on the association.

Scrollbar
1 1

Window Titlebar
1 1

Menu
1 1 .. *
 Composition
• A restricted form of Aggregation in which two
entities (or you can say classes) are highly
dependent on each other.
• A human needs a heart to live and a heart needs a
human body to function on. In other words when
the classes (entities) are dependent on each other
and their life span are same (if one dies then
another one does too) then it’s a composition.
 Multiplicity
• After specifying the type of association relationship by
connecting the classes, you can also declare the cardinality
between the associated entities. For example:

• The above UML diagram shows that a house has exactly

one kitchen, exactly one bath, at least one bedroom (can
have many), exactly one mailbox, and at most one
mortgage (zero or one).
 Multiplicity Constraints
• A multiplicity constraint can be
– a single number
– a “*”, meaning an arbitrarily large number or
simply “many”
– a range, denoted by “min..max”
– a sequence of single numbers and ranges
Multiplicity
• It allows us to set numerical constraints on relationships
• Some types of multiplicity are
• 1 – Just one
• n – Specific number
• 0..* - Zero to many
• 1..* - One to many (At least one)
• 0..1 – Zero or one (Optional)
• m..n – Specific number range
 Multiplicity Constraints
is registered for>
Student Semester
1..*
0..* 1

g>
rin
tak
es>

du
ld
he
0..8

is
1..*
teaches> Class
Instructor
Section
1..3 0..6
1..*
is
<works for

in
st
an
ce
of
>
1 sponsors>
1 1..*
Department Course
 Questions
• From the previous diagram
– How many classes can a student take?
– Do you have to be registered in any classes to be a
student?
– Do I need to teach this class to be an Instructor?
Do I need to teach ANY classes?
1. What type of core-relationship is represented by the symbol in the figure below?

a) Aggregation
b) Dependency
c) Generalization
d) Association
Answer: a
2. Which core element of UML is being shown in the figure?

a) Node
b) Interface
c) Class
d) Component
Answer: d
3. What type of relationship is represented by Shape class and Square ?

a) Realization
b) Generalization
c) Aggregation
d) Dependency
Answer: b
4. Consider a directed line (->) from the relation ship set advisor to both entity sets
instructor and student. This indicates ___________ cardinality.

a. One to many
b. One to one
c. Many to many
d. Many to one
Answer: b

5. An entity set that does not have sufficient attributes to form a primary key is
termed as a ____
a. Strong entity set
b. Variant set
c. Weak entity set
d. Variable set
Answer: c
Association Relationships (Cont’d)
We can indicate the multiplicity of an association by adding
multiplicity adornments to the line denoting the association.

The example indicates that a Student has one or more

Instructors:

Student Instructor
1..*
Association Relationships (Cont’d)
The example indicates that every Instructor has one or more
Students:

Student Instructor
1..*
Association Relationships (Cont’d)
We can also indicate the behavior of an object in an association
(i.e., the role of an object) using rolenames.

teaches learns from

Student Instructor
1..* 1..*
Association Relationships
(Cont’d)
We can also name the association.

membership
Student Team
1..* 1..*
Association Relationships
(Cont’d)
We can specify dual associations.

member of
1..* 1..*
Student Team
1 president of 1..*
Association Relationships
(Cont’d)
Associations can also be objects themselves, called link classes
or an association classes.
Registration
modelNumber
serialNumber
warrentyCode

Product Warranty
Association Relationships
(Cont’d)
A class can have a self association.

next

LinkedListNode
previous
Interfaces
An interface is a named set of
operations that specifies the behavior
<<interface>> of objects without showing their inner
ControlPanel structure. It can be rendered in the
model by a one- or two-compartment
rectangle, with the stereotype
<<interface>> above the interface
name.
A real world Example
A Simple C++ Program with class
Output
 Topic : Feature Abstraction and
Encapsulation, Application of Abstraction and
Encapsulation
 Abstraction
• Data abstraction allows a program to ignore the details of
how a data type is represented.

• Abstraction (derived from a Latin word abs, meaning away

from and trahere, meaning to draw) refers to the act of
representing essential features without including the
background details or explanations.

• C++ classes use the technique of abstraction and are defined

as a list of abstract attributes such as width, cost, size etc and
functions to operate on these attributes.
 Abstraction
• While classifying a class, both data members and member
functions are expressed in the code. But, while using an
object (that is an instance of a class) the built-in data types
and the members in the class get ignored which is known as
data abstraction.

• C++ provides a great level of data abstraction. In C++, we use

classes to define our own abstract data types (ADT).
Programmers can use the "cout" object of class ostream for
data streaming to standard output like this:
Abstraction - Example
 What is abstraction
• Abstract class in C++ is the one which is not used to create
objects.

• These type of classes are designed only to treat like a base

class (to be inherited by other classes).

• It is a designed technique for program development which

allows making a base upon which other classes may be built.
 Here is an example of declaring Public members of C++ class
#include <iostream>
using namespace std;
class sample {
public:
int gl, g2;
public:
void val()
{ cout << "Enter Two values : "; cin >> gl >> g2;
}
void display()
{
cout << gl << " " << g2;
cout << endl;
} };
int main() {
sample S;
S.val();
S.display();
}
Here is a Private member example in which member data cannot be accessed
• :

#include <iostream> outside the class

using namespace std; If you execute the above program, the private
class sample {
public:
member function will not be accessible and
int gl, g2; hence the following error message will appear
public: like this in some compiler:
void val()
{ cout << "Enter Two values : "; cin >> gl >> g2;
}
private:
void display()
{ cout << gl << " " << g2;
cout << endl;
}
};
int main()
{
sample S;
S.val();
S.display();
}
 Advantages of Data Abstraction
• Class internals get protected from user-level errors
• Programmer does not have to write the low-level code
• Code duplication is avoided and so programmer does not have to go over
again and again fairly common tasks every time to perform similar operation
• The main idea of abstraction is code reuse and proper partitioning across
classes
• For small projects, this may not seem useful but for large projects, it provides
conformity and structure as it provides documentation through the abstract
class contract
• It allows internal implementation details to be changed without affecting the
users of the abstraction
 Data Encapsulation
• Unable to deal with the complexity of an object, human chooses to
ignore its non-essential details and concentrate on the details which are
essential to our understanding.
• Abstraction is "looking for what you want" within an object or class.
• But there is another major concept connected to abstraction which is
called encapsulation.
• So basically, encapsulation can be defined as the process of hiding all of
the details of an object that do not throw in or dealt with its essential
characteristics.
• Encapsulation can also be defined as preventing access to non-essential
details of classes or its objects.
• Abstraction and encapsulation have close bonding among each other.
• Encapsulation assists abstraction by providing a means of suppressing
the non-essential details.
 ENCAPSULATION
ADVANTAGES
• Encapsulated classes reduce complexity.
• Help protect our data. A client cannot change an Account's balance if we
encapsulate it.
• Encapsulated classes are easier to change.
 Data Encapsulation
• Wrapping of data and functions into a single
unit is known as data encapsulation.
• Data is not accessible to the outside world,
only those functions which are wrapped in the
class can access it.
 Application of Abstraction
• For example, when you send an email to
someone you just click send and you get the
success message, what actually happens when
you click send, how data is transmitted over
network to the recipient is hidden from you
 Example

• The common example of encapsulation is Capsule. In capsule all medicine

are encapsulated in side capsule.

• Automatic Cola Vending Machine :Suppose you go to an automatic cola

vending machine and request for a cola. The machine processes your
request and gives the cola.
 Examples
Data Abstraction and Encapsulation
Any C++ program where you implement a class with public and private members is an
example of data encapsulation and data abstraction
#include <iostream>
using namespace std;
class Adder {
public:
// constructor
Adder(int i = 0) {
total = i;
}
// interface to outside world
void addNum(int number) {
total += number;
}

// interface to outside world

int getTotal() {
return total;
};
private:
// hidden data from outside world
int total;
};
 MCQ
1. Wrapping data and its related functionality into a single entity is known as
_____________
a) Abstraction
b) Encapsulation
c) Polymorphism
d) Modularity

2. Which concept enables programmers to assign a different meaning or usage

to a variable, function, or an object in different contexts?
(a) Inheritance
(b) Message passing
(c) Polymorphism
(d) Abstraction
 Examples
3. Which of the following is the functionality of ‘Data Abstraction’?
a) Reduce Complexity
b) Binds together code and data
c) Parallelism
d) None of the mentioned

4. How will a class protect the code inside it?

a) Using Access specifiers
b) Abstraction
c) Use of Inheritance
d) All of the mentioned
 Examples
5. What is the output of this program?
class Test {
int a;
public int b;
private int c;
}
class AcessTest {
public static void main(String args[])
{
Test ob = new Test();
ob.a = 10;
ob.b = 20;
ob.c = 30;
System.out.println(" Output :a, b, and c" + ob.a + " " + ob.b + " " + ob.c);
}
}
a) Compilation error
b) Run time error Private members of a class cannot be accessed
c) Output : a, b and c 10 20 30 directly. In the above program, the variable c is
d) None of the mentioned a private member of class ‘Test’ and can only
be accessed through its methods.
ACCESS SPECIFIERS
 Access control in classes

One of the main features of object-oriented programming languages such as C++ is

data hiding. Data hiding refers to restricting access to data members of a class. This is to
prevent other functions and classes from tampering with the class data.
Definition :
The access specifiers of C++ allows us to determine which class members are accessible
to other classes and functions, and which are not.

Types of C++ Access Specifiers are:

• public •: A public member is accessible from anywhere outside the class but within a
program.

• private : A private member variable or function cannot be accessed, or even viewed from
outside the class. Only the class and friend functions can access private members.

• protected : A protected member variable or function is very similar to a private member

but it provided one additional benefit that they can be accessed in child classes which are
called derived classes
Syntax of Declaring Access Specifiers in C++

class ClassName
{
private:
// declare private members/methods here
public:
// declare public members/methods here
protected:
// declare protected members/methods here
};

•
 Example 1: C++ public Access Specifier

#include <iostream>
int main()
using namespace std; {
class Sample // define a class Sample obj1; // declare a class object
{ cout << "Enter your age: ";
public: // public elements
int age; // store input in age of the obj1 object
cin >> obj1.age;
void displayAge()
{ obj1.displayAge(); // call class function
cout <<
•
"Age = " << age << endl; return 0;
} }
};

Output:

Enter your age: 20

Age = 20
 Example 2: C++ private Access Specifier

class Sample
{ int main()
private: // private elements {
int age; int ageInput;
Sample obj1;
public: // public elements cin >> obj1.age; // error
void displayAge(int a) cout << "Enter your age: ";
{ cin >> ageInput;
age = a; obj1.displayAge(ageInput);
•
cout << "Age = " << age << endl; return 0;
} }
};

Output:

Enter your age: 20

Age = 20
 Example 3 : C++ protected Access Specifier

class Sample // declare parent class int main()

{ {
protected: // protected elements int ageInput;
int age;
};
// declare object of child class
SampleChild child;
// declare child class cout << "Enter your age: ";
class SampleChild : public Sample cin >> ageInput;
{
public: // call child class function
void displayAge(int a) child.displayAge(ageInput);
{ return 0;
age = a;• }
cout << "Age = " << age << endl;
}

};
Output:

Enter your age: 20

Age = 20
 Access Specifiers Example 1
#include <iostream> // Main function for the program
using namespace std;
int main( )
class Line {
{ Line line;
public:
double length; // set line length
void setLength( double len ); line.setLength(6.0);
double getLength( void ); cout << "Length of line : " << line.getLength() <<endl;
};
// set line length without member function
double Line::getLength(void)
{ line.length = 10.0; // OK: because length is public
return length ; cout << "Length of line : " << line.length <<endl;
} return 0;
}
void Line::setLength( double len )
{
Length of line : 6
length = len; Length of line :
} 10
 Access Specifiers Example 2
#include <iostream>
using namespace std; // Main function for the program
int main( )
class Box {
Box box;
{
public: // set box length without member function
double length; box.length = 10.0; // OK: because length is public
void setWidth( double wid ); cout << "Length of box : " << box.length <<endl;
double getWidth( void );
// set box width without member function
private: // box.width = 10.0; // Error: because width is private
double width; box.setWidth(10.0); // Use member function to set it.
}; cout << "Width of box : " << box.getWidth() <<endl;

// Member functions definitions return 0;

double Box::getWidth(void) }
{
return width ;
}
Length of box :
void Box::setWidth( double wid ) 10 Width of box :
{
10
width = wid;
}
 Access Specifiers Example 3
#include <iostream> void SmallBox::setSmallWidth( double wid )
using namespace std; {
width = wid;
class Box }
{
protected: // Main function for the program
double width; int main( )
}; {
SmallBox box;
class SmallBox:Box
{ // set box width using member function
public: box.setSmallWidth(5.0);
void setSmallWidth( double wid ); cout << "Width of box : "<< box.getSmallWidth();
double getSmallWidth( void );
}; return 0;
}
// Member functions of child class
double SmallBox::getSmallWidth(void)
{ Width of box : 5
return width ;
}
 Revision Exercises

Write a C++ program to:

• Write a program using public and private class members.

Declare a data member c,d as private in a class and use it
in the functions (getinput() and showoutput()) derived in
public
•
and call the function using object of the class

• Write a program using protected access specifier. Use a

variable s,t declared in the protected section of the class in
the subclass of that class.Use getinput() and showoutput()
as functions.
Topic : UML use case Diagram, use
case, Scenario, Use case Diagram
objects and relations
USECASE DIAGRAM
•Use case diagrams give us that capability.
•Use case diagrams are used to depict the context of the system
to be built and the functionality provided by that system.
•They depict who (or what) interacts with the system. They show
what the outside world wants the system to do.
NOTATIONS
• Actors are entities that interface with the system.
• They can be people or other systems.
• Actors, which are external to the system they are
using, are depicted as stylized stick figures.
Relationship
Two relationships used primarily for
organizing use case models are both
powerful
• «include» relationship
• «extend» relationship
«include» relationship
• In our hydroponics example, we have an Update Crop Encyclopedia
use case.
• During analysis, we determine that the Nutritionist actor using that
use case will have to see what is in the crop encyclopedia prior to
updating it.
• This is why the Nutritionist can invoke the View Reports use case.
• The same is true for the Gardener actor whenever invoking Maintain
StorageTanks.
• Neither actor should be executing the use cases blindly. Therefore, the View
Report use case is a common functionality that both other use cases need.
• This can be depicted on the use case model via an «include» relationship, as
shown in Figure.
• This diagram states, for example, that the Update Crop Encyclopedia usecase
includes the View Reports use case.
• This means that View Reports must be executed when Update Crop
Encyclopedia is executed.
• UpdateCrop Encyclopedia would not be considered complete without View
Reports.
«extend» Relationships
• While developing your use cases, you may find that certain activities might be
performed as part of the use case but are not mandatory for that use case to run
successfully.
• In our example, as the Gardener actor executes the Manage Garden use case, he
or she may want to look at some reports.
• This could be done by using the View Reports use case.
• However, View Reports is not required when Manage Garden is run. Manage
Garden is complete in and of itself. So, we modify the use case diagram to indicate
that the View Reports use case extends the Manage Garden use case.
• Where an extending use case is executed, it is indicated in the use case
specification as an extension point.
• The extension point specifies where, in the flow of the including use case,
the extending use case is to be executed.
SAMPLE MCQ’S

1. UML diagram that shows the interaction between users and system, is known as
A. Activity diagram
B. E-R diagram
C. Use case diagram
D. Class diagram
Answer:C

2. A UML diagram that facilitates requirements gathering and interacts between

system and external users, is called as
A. Flowchart diagram
B. Sequence diagram
C. Use case diagram
D. Data flow diagram
Answer: C
SAMPLE MCQ’S
3. Which of the following is correct A or B and
why
SAMPLE MCQ’S
4. Which of the following is correct A or B and why
SAMPLE MCQ’S
4. Which of the following is correct A or B and why