All in 1

OOP COMPLETE NOTES
BY
Umer Tanvir

CSC241:
Object Oriented
Programming
Spring 2013
1. Starting OOP
May25,2013COMSATSInstituteofInformationTechnology
2
Please turn OFF your Mobile Phones!
Saturday, May 25, 2013
Farhan Aadil

Study Assignment
• I hope you did go through chapter 1 of both the books.
• How was the experience?
• What did you learn?
May 25, 2013 COMSATS Institute of Information Technology 3

Procedural vs. Object-Oriented
• Procedural
Withdraw, deposit, transfer
• Object Oriented
Customer, money, account

Object-Orientation
(OO)

What is Object-Orientation?
• A technique for system modeling
• OO model consists of several interacting objects

What is a Model?
• A model is an abstraction of something
• Purpose is to understand the product before developing it

Examples – Model
• Highway maps
• Architectural models
• Mechanical models

Example – OO Model

…Example – OO Model
• Objects
• Ali
• House
• Car
• Tree
• Interactions
• Ali lives in the house
• Ali drives the car
Ali
Car
House
Tree
lives-in
drives

Object-Orientation - Advantages
• People think in terms of objects
• OO models map to reality
• Therefore, OO models are
• easy to develop
• easy to understand

What is an Object?
An object is
• Something tangible (Ali, Car)
• Something that can be apprehended intellectually (Time, Date)

… What is an Object?
An object has
• State (attributes)
• Well-defined behaviour (operations)
• Unique identity

Example – Ali is a Tangible Object
• Name
• Age
• behaviour (operations)
• Walks
• Eats
• Identity
• His name

Example – Car is a Tangible Object
- Color
- Model
- Start Car
- Accelerate
- Change Gear
• Identity
- Its registration number

Example – Time is an Object Apprehended
Intellectually
- Hours - Seconds
- Minutes
- Set Hours - Set Seconds
- Set Minutes
• Identity
- Would have a unique ID in the model

Example – Date is an Object Apprehended
Intellectually
- Year - Day
- Month
- Set Year - Set Day
- Set Month
• Identity
- Would have a unique ID in the model

Definition
• What Is an Object?
• An object is a software bundle of related variables and methods.
Software objects are often used to model real-world objects you find
in everyday life.
• Objects are key to understanding object-oriented technology. You can
look around you now and see many examples of real-world objects:
dog, desk, television set, bicycle.

Real-world objects share two characteristics
• They all have state and behavior
• dogs have state (name, color, breed, hungry) and behavior (barking,
fetching, and wagging tail).
• Bicycles have state (current gear, current pedal cadence, two wheels,
number of gears) and behavior (braking, accelerating, slowing down,
changing gears).

Software objects are modeled after real-world
objects
• A software object maintains its state in one or more variables .
• A software object implements its behavior with methods . A method
is a function (subroutine) associated with an object.

Can represent real-world objects by using
software objects.
• You might want to represent real-world dogs as software objects in an
animation program or a real-world bicycle as a software object in the
program that controls an electronic exercise bike.
• You can also use software objects to model abstract concepts. For
example, an event is a common object used in GUI window systems to
represent the action of a user pressing a mouse button or a key on
the keyboard.

Moving to new thinking …
• C is a procedural language. A procedure is a list of
instructions.
• Very small programs (tens of lines) need no organization.
• As they get large (hundreds of lines), they are divided into
functions.
• Functions are still lists of instructions.
• Dividing a program into functions gives a structure to the
program (hence structured programming).

• C programming cannot do the following well:
• Functions have unrestricted access to global data.
• Data and Functions are unrelated; they do not form a
logical group or show any form of binding.
• Cannot model ‘real world’.
• In real world, we deal with objects like cars, people
etc.
• Are such objects like ‘data’? Which data type describes a
car, for example?
• Are such objects like ‘functions’? What will a function car()
do?

• A real world object, e.g. car:
• Is its description purely the ability to have a ‘data type’ to
represent its specifications or ‘attributes’ only? For
example what attributes describe a car?
• So by having all these attributes ‘only’ do you know all
about a car? Would you buy a car by merely looking at
these attributes and their values?
• No! What else do you wish to have?

• A real world object, e.g. car:
• Test drive! Right?
• What would you know through a test drive: how it
‘behaves’ in response to various stimulus!
• How can it negotiate a speed braker, a speedy turn, full braking
etc.
• Effectively, you wish to know how it ‘functions’.
• Behaviour is like a function.
• So neither data nor functions, by themselves, model
real-world objects effectively.

Object Oriented Approach …
• Neither data nor functions, by themselves, model real-
world objects effectively.
• OO languages (like C++) combine both ‘data’ and
‘functions that operate on that data’ into a single unit,
called ‘object’. Hence ‘encapsulating’ an entity.
• The objects functions are called member functions.
• Typically, data can be accessed through functions only. So
data gets ‘hidden’.
• Data hiding ensures the data is not accidentally altered.
• Reference analogy of a growing company; 2 people vs 100
employee company.
• Objects communicate with each other by calling each
other’s member functions.

Object Oriented Approach …
• OOP is all about ‘organization’ and not about program
operation. Most individual statements are similar to C
statements. Member functions may be very similar to
C procedural functions.
• In C you used to think about functions.
• In C++ you should think about objects.
• Often objects in C++ are real-world analogies.
• In C++ objects are ‘instances’ of ‘classes’. E.g. Honda
City is an instance of class car!
• Class serves as a cookie cutter and an object a cookie.

Abstraction
• Abstraction is a way to cope with complexity.
• Principle of abstraction:
“Capture only those details about an object that are relevant to current
perspective”

Example – Abstraction
• Attributes
- Name - Employee ID
- Student Roll No - Designation
- Year of Study - Salary
- CGPA - Age
Ali is a PhD student and teaches BS students

• behaviour
- Study - DevelopExam
- GiveExam - TakeExam
- PlaySports - Eat
- DeliverLecture - Walk
Ali is a PhD student and teaches BS students

Attributes
• - Name - Employee ID
• - Student Roll No - Designation
• - Year of Study - Salary
• - CGPA - Age
Student’s Perspective

• behaviour
- PlaySports - Eat
Student’s Perspective

• Attributes
- Name - Employee ID
- Student Roll No - Designation
- Year of Study - Salary
- CGPA - Age
Teacher’s Perspective

• behaviour
- PlaySports - Eat
Teacher’s Perspective

• Ordinary Perspective
A pet animal with
• Four Legs
• A Tail
• Two Ears
• Sharp Teeth
• Surgeon’s Perspective
A being with
• A Skeleton
• Heart
• Kidney
• Stomach
A cat can be viewed with different perspectives

Driver’s View
Engineer’s View

Abstraction – Advantages
• Simplifies the model by hiding irrelevant details
• Abstraction provides the freedom to defer implementation decisions
by avoiding commitment to details

Classes
• In an OO model, some of the objects exhibit identical characteristics
(information structure and behaviour)
• We say that they belong to the same class

Example – Class
• Ali studies mathematics
• Anam studies physics
• Sohail studies chemistry
• Each one is a Student
• We say these objects are instances of the Student class

Example – Class
• Ahsan teaches mathematics
• Aamir teaches computer science
• Atif teaches physics
• Each one is a teacher
• We say these objects are instances of the Teacher class

Graphical Representation of Classes
(Class Name)
(attributes)
(operations)
(Class Name)
Normal Form
Suppressed
Form

Example – Graphical Representation of
Classes
Circle
center
radius
draw
computeArea
Normal Form
Suppressed
Form
Circle

Example – Graphical Representation of
Classes
Person
name
age
gender
eat
walk
Normal Form
Suppressed
Form
Person

Inheritance
• A child inherits characteristics of its parents
• Besides inherited characteristics, a child may have its own unique
characteristics

Inheritance in Classes
• If a class B inherits from class A then it contains all the characteristics
(information structure and behaviour) of class A
• The parent class is called base class and the child class is called
derived class
• Besides inherited characteristics, derived class may have its own
unique characteristics

Example – Inheritance
Person
Teacher
DoctorStudent

Example – Inheritance
Shape
Circle
TriangleLine

Inheritance – “IS A” or
“IS A KIND OF” Relationship
• Each derived class is a special kind of its base class

Example – “IS A” Relationship
Person
name
age
gender
eat
walk
Teacher
designation
salary
teach
takeExam
Student
program
studyYear
study
heldExam
Doctor
designation
salary
checkUp
prescribe

Example – “IS A” Relationship
Shape
color
coord
draw
rotate
setColor
Circle
radius
draw
computeArea
Line
length
draw
Triangle
angle
draw
computeArea

Inheritance – Advantages
• Reuse
• Less redundancy
• Increased maintainability

Reuse with Inheritance
• Main purpose of inheritance is reuse
• We can easily add new classes by inheriting from existing classes
• Select an existing class closer to the desired functionality
• Create a new class and inherit it from the selected class
• Add to and/or modify the inherited functionality

Example Reuse
Shape
color
coord
draw
rotate
setColor
Circle
radius
draw
computeArea
Line
length
draw
Triangle
angle
draw
computeArea

Example Reuse
Person
name
age
gender
eat
walk
Teacher
designation
salary
teach
takeExam
Student
program
studyYear
study
heldExam
Doctor
designation
salary
checkUp
prescribe

References
• “Object Oriented Programming in C++”, by “Robert Lafore”, published by Sams Publishing (The
Waite Group). 4th ed. available in soft form.
• “Object Oriented Programming Using C++” by “Joyce Farrell” , published by Course Technology,
Cengage Learning. 4th ed. available in soft form
• National University of Computer & Emerging Sciences
[www.nu.edu.pk]
• Virtual University of Pakistan [ocw.vu.edu.pk]
• Open Courseware Consortium
[http://www.ocwconsortium.org/en/courses]
56

Thanks

CSC241:
Object Oriented
Programming
Spring 2013
1. Inheritance & Generalization
58
Farhan Aadil

Recap – Inheritance
• Derived class inherits all the characteristics of the base class
• Besides inherited characteristics, derived class may have its own
unique characteristics
• Major benefit of inheritance is reuse

Concepts Related with Inheritance
• Generalization
• Subtyping (extension)
• Specialization (restriction)

Generalization
• In OO models, some classes may have common characteristics
• We extract these features into a new class and inherit original classes
from this new class
• This concept is known as Generalization

Example – Generalization
Circle
color
vertices
radius
move
setColor
computeArea
Line
color
vertices
length
move
setColor
getLength
Triangle
color
vertices
angle
move
setColor
computeArea

Shape
color
vertices
move
setColor
Circle
radius
computeArea
Line
length
getLength
Triangle
angle
computeArea

Teacher
name
age
gender
designation
salary
teach
takeExam
eat
walk
Student
name
age
gender
program
studyYear
study
heldExam
eat
walk
Doctor
name
age
gender
designation
salary
checkUp
prescribe
eat
walk

Person
name
age
gender
eat
walk
Teacher
designation
salary
teach
takeExam
Student
program
studyYear
study
heldExam
Doctor
designation
salary
checkUp
prescribe

Sub-typing & Specialization
• We want to add a new class to an existing model
• Find an existing class that already implements some of the desired
state and behaviour
• Inherit the new class from this class and add unique behaviour to the
new class

Sub-typing (Extension)
• Sub-typing means that derived class is behaviourally compatible with
the base class
• Behaviourally compatible means that base class can be replaced by
the derived class

Example –
Sub-typing
(Extension)
Person
name
age
gender
eats
walks
Student
program
studyYear
study
takeExam

Example –
Sub-typing
(Extension)
Shape
color
vertices
setColor
move
Circle
radius
computeCF
computeArea

Specialization (Restriction)
• Specialization means that derived class is behaviourally incompatible
with the base class
• Behaviourally incompatible means that base class can’t always be
replaced by the derived class

Example – Specialization
(Restriction)
Person
age : [0..100]
…
Adult
age : [18..100]
…
setAge( a )
…
setAge( a )
…
age = a
If age < 18 then
error
else
age = a

Example – Specialization
(Restriction)
IntegerSet
…
NaturalSet
…
add( elem )
…
add( elem )
…
add element
to the set
If elem < 1 then
error
else
add element
to the set

Overriding
• A class may need to override the default behaviour provided by its
base class
• Reasons for overriding
• Provide behaviour specific to a derived class
• Extend the default behaviour
• Restrict the default behaviour
• Improve performance

Example – Specific Behaviour
Shape
color
vertices
draw
move
setColor
Circle
radius
draw
computeArea
Line
length
draw
Triangle
angle
draw
computeArea

Example – Extension
Window
width
height
open
close
draw
DialogBox
controls
enable
draw
1- Invoke Window’s
draw
2- draw the dialog
box

Example – Restriction
IntegerSet
…
NaturalSet
…
add( elem )
…
add( elem )
…
Add element to
the set
If elem < 1 then
give error
else
Add element to
the set

Example – Improve Performance
• Class Circle overrides
rotate operation of class
Shape with a Null
operation.
Shape
color
coord
draw
rotate
setColor
Circle
radius
draw
rotate

Abstract Classes
• An abstract class implements an abstract concept
• Main purpose is to be inherited by other classes
• Can’t be instantiated
• Promotes reuse

Example – Abstract Classes
• Here, Person is an abstract classMay 25, 2013 COMSATS Institute of Information Technology 79
Teacher
DoctorStudent
Person
name
age
gender
eat
walk

Example – Abstract Classes
• Here, Vehicle is an abstract classMay 25, 2013 COMSATS Institute of Information Technology 80
Bus
TruckCar
Vehicle
color
model
accelerate
applyBrakes

Concrete Classes
• A concrete class implements a concrete concept
• Main purpose is to be instantiated
• Provides implementation details specific to the domain context

Example – Concrete Classes
• Here, Student, Teacher and Doctor are concrete
classesMay 25, 2013 COMSATS Institute of Information Technology 82
Teacher
DoctorStudent
program
studyYear
study
heldExam
Person

Example – Concrete Classes
• Here, Car, Bus and Truck are concrete classes
Bus
Car
Vehicle
Truck
capacity
load
unload

Multiple Inheritance
• We may want to reuse characteristics of more than one parent class

Example – Multiple Inheritance
Mermaid

Mermaid
Woman Fish

Amphibious Vehicle

Amphibious Vehicle
Land Vehicle Water Vehicle
Vehicle
Car Boat

Problems with Multiple Inheritance
• Increased complexity
• Reduced understanding
• Duplicate features

Problem – Duplicate Features
• Which eat operation Mermaid inherits?
Mermaid
Woman Fish
eat
…
eat
…

Solution – Override the Common Feature
Mermaid
Woman Fish
eat
…
eat
…
eat
…
Invoke eat
operation of
desired class

Problem – Duplicate Features
(Diamond Problem)
• Which changeGear operation Amphibious Vehicle
inherits?
Amphibious Vehicle
Land Vehicle Water Vehicle
Vehicle
Car Boat
changeGear

Solution to Diamond Problem
• Some languages disallow diamond hierarchy
• Others provide mechanism to ignore characteristics
from one side

Association
• Objects in an object model interact with each other
• Usually an object provides services to several other objects
• An object keeps associations with other objects to delegate tasks

Kinds of Association
• Class Association
• Inheritance
• Object Association
• Simple Association
• Composition
• Aggregation

Simple Association
• Is the weakest link between objects
• Is a reference by which one object can interact with some other
object
• Is simply called as “association”

Kinds of Simple Association
• w.r.t navigation
• One-way Association
• Two-way Association
• w.r.t number of objects
• Binary Association
• Ternary Association
• N-ary Association

One-way Association
• We can navigate along a single direction only
• Denoted by an arrow towards the server object

Example – Association
• Ali lives in a House
Ali House
lives-in
11

• Ali drives his Car
Ali Car
drives
*1

Two-way Association
• We can navigate in both directions
• Denoted by a line between the associated objects

Example – Two-way Association
• Employee works for company
• Company employs employees
Employee Company
works-for
1*

• Yasir is a friend of Ali
• Ali is a friend of Yasir
Yasir Ali
friend
11

Binary Association
• Associates objects of exactly two classes
• Denoted by a line, or an arrow between the associated objects

Example – Binary Association
• Association “works-for” associates objects of exactly
two classes
Employee Company
works-for
1*

• Association “drives” associates objects of exactly two
classes
Ali Car
drives
*1

Ternary Association
• Associates objects of exactly three classes
• Denoted by a diamond with lines connected to associated objects

Example – Ternary Association
• Objects of exactly three classes are associated
Student Teacher
Course
1
*
*

Project Language
Person
*
1
*

N-ary Association
• An association between 3 or more classes
• Practical examples are very rare

Composition
• An object may be composed of other smaller objects
• The relationship between the “part” objects and the “whole” object
is known as Composition
• Composition is represented by a line with a filled-diamond head
towards the composer object

Example – Composition of Ali
Ali
Body
Arm
Head
Leg
1
1
2 2

Example – Composition of Chair
Chair
SeatArm
Back
Leg
1
12 4

Composition is Stronger
• Composition is a stronger relationship, because
• Composed object becomes a part of the composer
• Composed object can’t exist independently

Example – Composition is Stronger
• Ali is made up of different body parts
• They can’t exist independent of Ali

• Chair’s body is made up of different parts
• They can’t exist independently

Aggregation
• An object may contain a collection (aggregate) of other objects
• The relationship between the container and the contained object is
called aggregation
• Aggregation is represented by a line with unfilled-diamond head
towards the container

Example – Aggregation
Room
Cupboard
Bed
Chair Table
*
1
1
1

Garden Plant*

Aggregation is Weaker
• Aggregation is weaker relationship, because
• Aggregate object is not a part of the container
• Aggregate object can exist independently

Example – Aggregation is Weaker
• Furniture is not an intrinsic part of room
• Furniture can be shifted to another room, and so can exist
independent of a particular room

• A plant is not an intrinsic part of a garden
• It can be planted in some other garden, and so can exist independent
of a particular garden

References
[www.nu.edu.pk]
123

Thanks

CSC241:
Object Oriented
Programming
Spring 2013
1. Inheritance Concepts
2. Polymorphism
May 25, 2013 COMSATS Intitute of Information Technology
125
Farhan Aadil

Class diagram showing
inheritance
May 25, 2013 COMSATS Intitute of Information Technology 126
Inheritance among classes is
shown as open triangular
arrowhead in UML Class
Diagram.
Arrow be read as “derived
from”.

Association
• Objects in an object model interact with each other
• Usually an object provides services to several other objects
• An object keeps associations with other objects to delegate tasks

Kinds of Association
• Class Association
• Inheritance
• Object Association
• Simple Association
• Composition
• Aggregation

Simple Association
• Is the weakest link between objects
• Is a reference by which one object can interact with some other
object
• Is simply called as “association”

Kinds of Simple Association
• w.r.t navigation
• One-way Association
• Two-way Association
• w.r.t number of objects
• Binary Association
• Ternary Association
• N-ary Association

One-way Association
• We can navigate along a single direction only
• Denoted by an arrow towards the server object

• Ali lives in a House
Ali House
lives-in
11

• Ali drives his Car
Ali Car
drives
*1

Two-way Association
• We can navigate in both directions
• Denoted by a line between the associated objects

• Employee works for company
• Company employs employees
Employee Company
works-for
1*

• Yasir is a friend of Ali
• Ali is a friend of Yasir
Yasir Ali
friend
11

Binary Association
• Associates objects of exactly two classes
• Denoted by a line, or an arrow between the associated objects

• Association “works-for” associates objects of exactly
two classes
Employee Company
works-for
1*

• Association “drives” associates objects of exactly two
classes
Ali Car
drives
*1

Ternary Association
• Associates objects of exactly three classes
• Denoted by a diamond with lines connected to associated objects

Student Teacher
Course
1
*
*

Project Language
Person
*
1
*

N-ary Association
• An association between 3 or more classes
• Practical examples are very rare

association
• Association among classes is shown as a simple arrow (ray) in UML (Unified
Modeling Language) Class Diagram.
• The direction of arrow shows ‘navigability’.
• time12 calls time24.
• This is unidirectional association.
• If both classes call operation of the other, navigability is both sided (bidirectional
association).

Composition
• An object may be composed of other smaller objects
• The relationship between the “part” objects and the “whole” object
is known as Composition
• Composition is represented by a line with a filled-diamond head
towards the composer object

composition
Composition among classes is shown as solid diamond arrowhead in UML Class
Diagram.

Example – Composition of Ali
Ali
Body
Arm
Head
Leg
1
1
2 2

Example – Composition of Chair
Chair
SeatArm
Back
Leg
1
12 4

Composition is Stronger
• Composition is a stronger relationship, because
• Composed object becomes a part of the composer
• Composed object can’t exist independently

• Ali is made up of different body parts
• They can’t exist independent of Ali

• Chair’s body is made up of different parts
• They can’t exist independently

Composition
• Composition is a ‘consists of’ relationship.
• COURSE_DATA consists of STUDENT_DATA (besides other things).
• STUDENT_DATA lifetime is the same as COURSE_DATA.
• Part may belong to only one whole.
• The lifetime of the part is the same as the lifetime of the whole.
May 25, 2013 National University of Computer and Emerging Sciences 152

Aggregation
• An object may contain a collection (aggregate) of other objects
• The relationship between the container and the contained object is
called aggregation
• Aggregation is represented by a line with unfilled-diamond head
towards the container

aggregation
Aggregation among classes is shown as open diamond arrowhead in UML Class
Diagram.

Room
Cupboard
Bed
Chair Table
*
1
1
1

Garden Plant*

Aggregation is Weaker
• Aggregation is weaker relationship, because
• Aggregate object is not a part of the container
• Aggregate object can exist independently

• Furniture is not an intrinsic part of room
• Furniture can be shifted to another room, and so can exist
independent of a particular room

• A plant is not an intrinsic part of a garden
• It can be planted in some other garden, and so can exist independent
of a particular garden

More about „struct‟
• More on data hiding
• By default all the data members of struct are
accessible (through the struct variable/object)
• This behaviour is known as data being ‘public’.
• We can hide them by explicitly marking them as
‘private’.
• public: data or functions, can be accessed from
anywhere, outside or inside.
• private: data or functions, cannot be accessed from
outside.

More about „struct‟ …
struct TEST
{
int x;
}
TEST var;
var.x = 10;
struct TEST
{
public:
int x;
}
TEST var;
var.x = 10;
struct TEST
{
private:
int x;
}
TEST var;
var.x = 10;
//error

struct stack {
int data[100];
int top;
} S;
///////////////////////////////////
void push(stack S, int a){
assert(top<100);
S.data[top]=a; S.top++;
}

struct TEST
{
private:
int x;
public:
void Setx(int val) { x = val; };
int Getx() { return x; };
}
TEST var;
var.Setx(10);
int y = var.Getx();
struct TEST
{
private:
int x;
}
TEST var;
var.x = 10; //e
int y = var.x; //e
So even legitimate access of data goes through an interface!
We have secured the data further!!!

Member functions definition
struct TEST {
private:
int x;
public:
void Setx(int val);
int Getx();
}
void TEST::Setx(int val) {
x = val;
}
int TEST::Getx() {
return x;
}
main() {
TEST var;
var.Setx(10);
int y = var.Getx();
}
• We can declare member
functions inside the
struct and define them
outside as well using the
name of struct to resolve
ambiguity.
• V. IMP: Note that this
allows us to separate
header and
implementation files!

Class Compatibility
• A class is behaviorally compatible with another if it supports all the
operations of the other class
• Such a class is called subtype
• A class can be replaced by its subtype

…Class Compatibility
• Derived class is usually a subtype of the base class
• It can handle all the legal messages (operations) of the base class
• Therefore, base class can always be replaced by the derived class

Example – Class Compatibility
Shape
color
vertices
move
setColor
draw
Circle
radius
draw
computeArea
Line
length
draw
getLength
Triangle
angle
draw
computeArea

Example – Class Compatibility
File
size
…
open
print
…
ASCII File
…
print
…
PDF File
…
print
…
PS File
…
print
…

Polymorphism
• In general, polymorphism refers to existence of different forms of a
single entity
• For example, both Diamond and Coal are different forms of Carbon

Polymorphism in OO Model
• In OO model, polymorphism means that different objects can behave
in different ways for the same message (stimulus)
• Consequently, sender of a message does not need to know exact class
of the receiver

Example – Polymorphism
Shape
Line Circle Triangle
draw
draw
draw draw
draw
View

Example – Polymorphism
File
ASCII File PDF File PS File
print
print
print print
print
Editor

Polymorphism – Advantages
• Messages can be interpreted in different ways
depending upon the receiver class
Shape
draw
draw
draw draw
draw
View

• New classes can be added without changing the existing
model
Square
draw
Shape
draw
draw
draw draw
draw
View

• In general, polymorphism is a powerful tool to develop flexible and
reusable systems

Object-Oriented
Modeling
An Example

Problem Statement
• Develop a graphic editor that can draw different geometric shapes
such as line, circle and triangle. User can select, move or rotate a
shape. To do so, editor provides user with a menu listing different
commands. Individual shapes can be grouped together and can
behave as a single shape.

Identify Classes
Extract nouns in the problem statement
• Develop a graphic editor that can draw different geometric shapes
such as line, circle and triangle. User can select, move or rotate a
shape. To do so, editor provides user with a menu listing different
commands. Individual shapes can be grouped together and can
behave as a single shape.

…Identify Classes
Eliminate irrelevant classes
• Editor – Very broad scope
• User – Out of system boundary

…Identify Classes
Add classes by analyzing requirements
• Group – required to behave as a shape
• “Individual shapes can be grouped together and can behave as a single
shape”
• View – editor must have a display area

…Identify Classes
• Shape
• Line
• Circle
• Triangle
• Menu
• Group
• View
Following classes have been identified:

Object Model – Graphic Editor
Line
Circle
Triangle
GroupShape
View
Menu

Identify Associations
Extract verbs connecting objects
•“Individual shapes can be grouped together”
• Group consists of lines, circles, triangles
• Group can also consists of other groups
(Composition)

… Identify Associations
Verify access paths
• View contains shapes
• View contains lines
• View contains circles
• View contains triangles
• View contains groups
(Aggregation)

… Identify Associations
Verify access paths
• Menu sends message to View
(Simple One-Way Association)

TriangleCircleLine
ShapeView
nnnn
nn
nn
Menu
Group
nn
nnnn
nn
nn

Identify Attributes
Extract properties of the object
• From the problem statement
• Properties are not mentioned

…Identify Attributes
• From the domain knowledge
• Line
– Color
– Vertices
– Length
• Circle
– Color
– Vertices
– Radius
• Triangle
– Color
– Vertices
– Angle
• Shape
– Color
– Vertices

…Identify Attributes
• From the domain knowledge
• Group
– noOfObjects
• View
– noOfObjects
– selected
• Menu
– Name
– isOpen

Menu
name
isOpen
View
noOfObjects
selected
Shape
color
vertices
Line
length
Circle
radius
Group
noOfObjects
Triangle
angle
nn
n
nn
n
nn
n
n
n
n
nn
nn
n

Identify Operations
Extract verbs connected with an object
• Develop a graphic editor that can draw
different geometric shapes such as line,
circle and triangle. User can select, move
or rotate a shape. To do so, editor provides
user with a menu listing different
commands. Individual shapes can be
grouped together and can behave as a
single shape.

… Identify Operations
Eliminate irrelevant operations
• Develop – out of system boundary
• Behave – have broad semantics

…Identify Operations
Following are selected operations:
• Line
– Draw
– Select
– Move
– Rotate
• Circle
– Draw
– Select
– Move
– Rotate

• Triangle
– Draw
– Select
– Move
– Rotate
• Shape
– Draw
– Select
– Move
– Rotate

• Group
– Draw
– Select
– Move
– Rotate
• Menu
– Open
– Select
– Move
– Rotate

Extract operations using domain knowledge
• View
– Add
– Remove
– Group
– Show
– Select
– Move
– Rotate

Group
noOfObjects
draw()
Triangle
angle
draw()
nn
Circle
radius
draw()
nn
Line
length
draw()
nn
Shape
color
vertices
draw()
select()
move()
rotate()
nn
View
noOfObjects
selected
add()
remove()
group()
show()
select()
move()
rotate()
nn
nn
nn
nn
Menu
name
isOpen
open()
select()
move()
rotate()
n

Identify Inheritance
Search “is a kind of” by looking at keywords like “such as”, “for
example”, etc
• “…shapes such as line, circle and triangle…”
– Line, Circle and Triangle inherits from Shape

…Identify Inheritance
By analyzing requirements
• “Individual shapes can be grouped together and can behave as a
single shape”
• Group inherits from Shape

Refining the Object Model
• Application of inheritance demands an iteration over the whole
object model
• In the inheritance hierarchy,
• All attributes are shared
• All associations are shared
• Some operations are shared
• Others are overridden

…Refining the Object Model
Share associations
• View contains all kind of shapes
• Group consists of all kind of shapes

Share attributes
• Shape – Line, Circle, Triangle and Group
• Color, vertices

Share operations
• Select
• Move
• Rotate

Share the interface and override implementation
• Draw

Line
length
draw()
Circle
radius
draw()
Triangle
angle
draw()
Group
noOfObjects
draw()
Shape
color
vertices
draw()
select()
move()
rotate()
n
View
noOfObjects
selected
add()
remove()
group()
show()
select()
move()
rotate()
nn
Menu
name
isOpen
open()
select()
move()
rotate()
n

Group
noOfObjects
draw()
Triangle
angle
draw()
nn
Circle
radius
draw()
nn
Line
length
draw()
nn
Shape
color
vertices
draw()
select()
move()
rotate()
nn
View
noOfObjects
selected
add()
remove()
group()
show()
select()
move()
rotate()
nn
nn
nn
nn
Menu
name
isOpen
open()
select()
move()
rotate()
n

Class
• Class is a tool to realize objects
• Class is a tool for defining a new type

Example
• Lion is an object
• Student is an object
• Both has some attributes and some behaviors

Uses
• The problem becomes easy to understand
• Interactions can be easily modeled

Type in C++
• Mechanism for user defined types are
• Structures
• Classes
• Built-in types are like int, float and double
• User defined type can be
• Student in student management system
• Circle in a drawing software

Abstraction
• Only include details in the system that are required for making a
functional system
• Student
• Name
• Address
• Sibling
• Father Business
Relevant to our problem
Not relevant to our problem

Defining a New User Defined Type
class ClassName
{
…
DataType MemberVariable;
ReturnType MemberFunction();
…
};
Syntax
Syntax

Example
class Student
{
int rollNo;
char *name;
float CGPA;
char *address;
…
void setName(char *newName);
void setRollNo(int newRollNo);
…
};
Member variables
MemberFunctions

Why Member Function
• They model the behaviors of an object
• Objects can make their data invisible
• Object remains in consistent state

Example
Student aStudent;
aStudent.rollNo = 514;
aStudent.rollNo = -514; //Error

Object and Class
• Object is an instantiation of a user defined type or a class

Declaring class variables
• Variables of classes (objects) are declared just like variables of
structures and built-in data types
TypeName VaraibaleName;
int var;
Student aStudent;

Accessing members
• Members of an object can be accessed using
• dot operator (.) to access via the variable name
• arrow operator (->) to access via a pointer to an object
• Member variables and member functions are accessed in a similar
fashion

Example
class Student{
int rollNo;
void setRollNo(int
aNo);
};
Student aStudent;
aStudent.rollNo;
Error

struct -> class transition!
class TEST {
private:
int x;
public:
}
main() {
TEST var;
var.Setx(10);
int y = var.Getx();
}
struct TEST {
private:
int x;
public:
}
main() {
TEST var;
var.Setx(10);
int y = var.Getx();
}
• Replacing struct with class, does not have any affect!
• This is the keyword that OOL (C++) provide for OOP!

Diff. between struct & class
class TEST {
int x;
}
main() {
TEST var;
var.x = 10; //error
var.Setx(10); //error
int y = var.Getx(); //error
}
struct TEST {
int x;
}
main() {
TEST var;
var.x = 10; //possible
var.Setx(10);
int y = var.Getx();
}
• By default struct (C++) members are public,
whereas class members are private.

Diff. between struct & class
class TEST {
int x;
public:
}
main() {
TEST var;
var.x = 10; //error
var.Setx(10);
int y = var.Getx();
}
struct TEST {
private:
int x;
public:
}
main() {
TEST var;
var.x = 10; //error
var.Setx(10);
int y = var.Getx();
}
• By default struct (C++) members are public,
whereas class members are private.

Access specifiers

Access specifiers
• There are three access specifiers
• ‘public’ is used to tell that member can be accessed whenever you have
access to the object
• ‘private’ is used to tell that member can only be accessed from a member
function
• ‘protected’ to be discussed when we cover inheritance

Example
class Student{
private:
char * name;
int rollNo;
public:
void setName(char *);
void setRollNo(int);
...
};
Cannot be accessed outside class
Can be
accessed
outside class

Example
class Student{
...
int rollNo;
public:
void setRollNo(int aNo);
};
int main(){
Student aStudent;
aStudent.SetRollNo(1);
}

Default access specifiers
• When no access specifier is mentioned then by default the member is
considered private member

Example
class Student
{
char * name;
int RollNo;
};
class Student
{
private:
char * name;
int RollNo;
};

Example
class Student
{
char * name;
int RollNo;
void SetName(char *);
};
Student aStudent;
aStudent.SetName(Ali);
Error

Example
class Student
{
char * name;
int RollNo;
public:
void setName(char *);
};
Student aStudent;
aStudent.SetName(“Ali”);

Unified Modeling Language (UML) class diagram
May 25, 2013 National University of Computer and Emerging Sciences 232 of 21
10..*
abstract
static
private
association
(“using”)
inheritance
(“is a”)

Assignment (CP)
• Install IBM Rational Rose or any other UML tool and draw the
diagrams used in this lecture and take a print out of those diagrams to
show me what you have done.
• Deadline: next class

References
[www.nu.edu.pk]

Thanks

CSC241:
Object Oriented
Programming
Spring 2013
1. Inheritance Concepts
2. Polymorphism
236
Farhan Aadil

Review
• Class
• Concept
• Definition
• Data members
• Member Functions
• Access specifier

Member Functions
• Member functions are the functions that operate on the data
encapsulated in the class
• Public member functions are the interface to the class

Member Functions (contd.)
• Define member function inside the class definition
OR
• Define member function outside the class definition
• But they must be declared inside class definition

Function Inside Class Body
class ClassName {
…
public:
ReturnType FunctionName() {
…
}
};

Example
•Define a class of student that has
a roll number. This class should
have a function that can be used
to set the roll number

Example
class Student{
int rollNo;
public:
void setRollNo(int aRollNo){
rollNo = aRollNo;
}
};

Function Outside Class Body
class ClassName{
…
public:
ReturnType FunctionName();
};
ReturnType ClassName::FunctionName()
{
…
}
Scope
resolution
operator

Example
class Student{
…
int rollNo;
public:
void setRollNo(int aRollNo);
};
void Student::setRollNo(int aRollNo){
…
rollNo = aRollNo;
}

Inline Functions
• Instead of calling an inline function compiler replaces the code at the
function call point
• Keyword ‘inline’ is used to request compiler to make a function inline
• It is a request and not a command

Example
inline int Area(int len, int hi)
{
return len * hi;
}
int main()
{
cout << Area(10,20);
}

Inline Functions
• If we define the function inside the class body then the function is by
default an inline function
• In case function is defined outside the class body then we must use
the keyword ‘inline’ to make a function inline

Example
class Student{
int rollNo;
public:
void setRollNo(int aRollNo){
…
rollNo = aRollNo;
}
};

Example
class Student{
…
public:
inline void setRollNo(int aRollNo);
};
void Student::setRollNo(int aRollNo){
…
rollNo = aRollNo;
}

Example
class Student{
…
public:
};
inline void Student::setRollNo(int
aRollNo){
…
rollNo = aRollNo;
}

Example
class Student{
…
public:
inline void setRollNo(int aRollNo);
};
inline void Student::setRollNo(int
aRollNo){
…
rollNo = aRollNo;
}

Constructor
• Constructor is used to initialize the objects of a class
• Constructor is used to ensure that object is in well defined state at
the time of creation
• Constructor is automatically called when the object is created
• Constructor are not usually called explicitly

Constructor (contd.)
• Constructor is a special function having same name as the class name
• Constructor does not have return type
• Constructors are commonly public members

Example
class Student{
…
public:
Student(){
rollNo = 0;
…
}
};

Example
int main()
{
Student aStudent;
/*constructor is implicitly called at this
point*/
}

Default Constructor
• Constructor without any argument is called default constructor
• If we do not define a default constructor the compiler will generate a
default constructor
• This compiler generated default constructor initialize the data
members to their default values

Example
class Student
{
int rollNo;
char *name;
float GPA;
public:
… //no constructors
};

Example
Compiler generated default constructor
{
rollNo = 0;
GPA = 0.0;
name = NULL;
}

Constructor Overloading
• Constructors can have parameters
• These parameters are used to initialize the data members with user
supplied data

Example
class Student{
…
public:
Student();
Student(char * aName);
Student(char * aName, int aRollNo);
Student(int aRollNo, int aRollNo, float aGPA);
};

Example
Student::Student(int aRollNo,
char * aName){
if(aRollNo < 0){
rollNo = 0;
}
else {
rollNo = aRollNo;
}
…
}

Example
int main()
{
Student student1;
Student student2(“Name”);
Student student3(”Name”, 1);
Student student4(”Name”,1,4.0);
}

Constructor Overloading
• Use default parameter value to reduce the writing effort

Example
Student::Student( char * aName = NULL,
int aRollNo= 0,
float aGPA = 0.0){
…
}
Is equivalent to
Student();
Student(char * Name, int aRollNo, float aGPA);

References
[www.nu.edu.pk]

How to correctly Search for a
software @ google
• When we need a software, the first place where we
go is at Google Search. If you don't know the
software name, then we use some keywords at
Google Search (for e.g. Note Taking software, Video
Editing software, Photo Editing software etc). Once
Google show us the results, we click the links after
reading its title and some description. Following such
practice often wastes our time by clicking useless
links. What most of the people don't know is that,
you can easily search for the software / applications
at Google Search using its filtering options. Let's see
how we can do that
• Consult the file uploaded

Thanks

CSC241:
Object Oriented
Programming
Spring 2013
1. Functions
Farhan Aadil

Revision
• Chapter 5 of book

Functions
 A function groups a number of program statements into a unit
and gives it a name.
 This unit can then be invoked from other parts of the program.
 The most important reason to use functions is to aid in the
conceptual organization of a program
 Another reason to use functions is to reduce program size. Any
sequence of instructions that appears in a program more than
once is a candidate for being made into a function.
 The function’s code is stored in only one place in memory, even
though the function is executed many times in the course of the
program.

Return type
Input argumentsMay 25, 2013 COMSATS Intitute of Information Technology 272

Functions
//demonstrates a simple function
#include <iostream>
using namespace std;
int cube(int x); // function deration
int main(){ // tests the cube() function:
int n = 1;
while (n != 0){
cin >> n;
cout << "tcube(" << n << ") = “
<< cube(n) << endl; // Calling a function
} // end of while loop
system("PAUSE"); return 0;
}//end of main
int cube( int x ){ // function definition
return x*x*x; // returns cube of x:
} // { function body }
Input Arguments
Return type

Functions
 Each integer read is passed to the cube() function by the call cube(n). The value
returned by the function replaces the expression cube(n) and then is passed to
the output object cout
 The main() function passes the value 5 to the cube() function, and the cube()
function returns the value 125 to the main() function.
 The argument n is passed by value to the formal parameter x. This simply means
that x is assigned the value of n when the function is called.

Default Arguments
#include <iostream>
//declaration with default arguments
void repchar(char='*', int=45);
int main(){
repchar(); //prints 45 asterisks
repchar('='); //prints 45 equal signs
repchar('+', 30); //prints 30 plus signs
}
// displays line of characters
void repchar(char ch, int n){
// defaults supplied if necessary
for(int j=0; j<n; j++) // loops n times
cout << ch; // prints ch
cout << endl;
}

Inline Function
 A function call involves substantial overhead.
Extra time and space have to be used to invoke
the function, pass parameters to it, allocate
storage for its local variables, store the
current variables and the location of execution
in the main program, etc.
 In some cases, it is better to avoid all this
by specifying the function to be inline. This
tells the compiler to replace each call to the
function with explicit code for the function.
 To the programmer, an inline function appears
the same as an ordinary function, except for
the use of the inline specifier.

Inline Function
// demonstrates inline functions
#include <iostream>
inline float lbstokg(float pounds){
// converts pounds to kilograms
return 0.453592 * pounds;
}
int main(){
float lbs;
cout << "nEnter your weight in pounds: ";
cin >> lbs;
cout << "Your weight in kilograms is " << lbstokg(lbs)
<< endl;
return 0;
}

Recursion
 The existence of functions makes possible a
programming technique called recursion.
 Recursion involves a function calling
itself. This sounds rather improbable, and
indeed a function calling itself is often a
bug. However, when used correctly this
technique can be surprisingly powerful.
 Recursion is much easier to understand with
an example than with lengthy explanations,
so let‟s apply it to a program:
 The next program, uses recursion instead of
a loop to calculate factorial.

Recursion
#include <iostream>
// calls itself to calculate factorials
unsigned long fct(unsigned long n){
static int I = 0; I++;
cout << "You Called Me " << I << " times" << endl;
if(n > 1)
return n * fct(n-1); //self call
else
return 1;
}
int main(){
int n;
cout << "Enter an integer: "; cin >> n;
cout << "Factorial of " << n << " is " << fct(n) << "n";
}

Recursion

References

Thanks

CSC241:
Object Oriented
Programming
Spring 2013
1. Constructors
283
Farhan Aadil

Constructor
• Constructor is used to initialize the objects of a class
• Constructor is used to ensure that object is in well defined state at
the time of creation (Lion 4 legs, Roll No +ve int)
• Constructor is automatically called when the object is created
• Constructor are not usually called explicitly

Example
class Student{
…
public:
Student();
Student(char * aName, int aRollNo, float aGPA);
};

Copy Constructor
• Copy constructor are used when:
• Initializing an object at the time of creation
• When an object is passed by value to a function

Example
void func1(Student student){
…
}
int main(){
Student studentA;
Student studentB = studentA;
func1(studentA);
}

Copy Constructor (Syntax)
Student::Student(
const Student &obj){
rollNo = obj.rollNo;
name = obj.name;
GPA = obj.GPA;
}

Shallow Copy
• When we initialize one object with another then the compiler copies
state of one object to the other
• This kind of copying is called shallow copying

Example
Student studentA;
Student studentB = studentA;
Name
GPA
RollNo
studentA
Name
GPA
RollNo
studentB
A
H
M
A
D
…
Memory

Assignment
• Lab Assignment No 3

References
[www.nu.edu.pk]

Thanks

CSC241:
Object Oriented
Programming
Spring 2013
1. Destructor
Farhan Aadil

Review
•Copy constructors
•Destructor
•this Pointer
•Separation of interface and
implementation

Destructor
• You might guess that another function is called
automatically when an object is destroyed. This is indeed
the case. Such a function is called a destructor.
• A destructor also has the same name as the class name
but is preceded by a tilde (~) sign:
• Like constructors, destructors do not have a return value.
They also take no arguments.
• The most common use of destructors is to de-allocate
memory that was allocated for the object by the
constructor.

Using Destructor
// foo.cpp demonstrates destructor
#include <iostream>
class Foo{
private:
int data;
public:
Foo() : data(0) // constructor (same name as class)
{cout<< "Wakeup n" ; }
~Foo() // destructor (same name with tilde)
{cout<< "ByeBye n" ; }
};
int main(){
Foo s1, s2; // define two objects of class Foo
system( "PAUSE" ); // Foo *s3; s3 = new Foo; delete s3;
return 0;
}

this Pointer
•There are situations where
designer wants to return
reference to current object from a
function
•In such cases reference is taken
from this pointer like (*this)

Example
Student Student::setRollNo(int aNo)
{
…
return *this;
}
Student Student::setName(char *aName)
{
…
return *this;
}

Example
int main()
{
Student aStudent;
Student bStudent;
bStudent = aStudent.setName(“Ahmad”);
…
bStudent = aStudent.setName(“Ali”).setRollNo(2);
return 0;
}

Separation of interface and
implementation
•Public member function exposed by a
class is called interface
•Separation of implementation from the
interface is good software engineering

Complex Number
•There are two representations of complex
number
• Euler form
• z = x + i y
• Phasor form
• z = |z| (cos  + i sin )
• z is known as the complex modulus and  is known as
the complex argument or phase

Example
float getX()
float getY()
void setNumber
(float i, float j)
…
float x
float y
Complex
Old implementation
float getX()
float getY()
void setNumber
(float i, float j)
…
float z
float theta
Complex
New implementation

Example
class Complex{ //old
float x;
float y;
public:
void setNumber(float i, float j){
x = i;
y = j;
}
…
};

Example
class Complex{ //new
float z;
float theta;
public:
void setNumber(float i, float j){
theta = arctan(j/i);
…
}
…
};

Advantages
•User is only concerned about ways of accessing
data (interface)
•User has no concern about the internal
representation and implementation of the class

Separation of interface and
implementation
•Usually functions are defined in implementation
files (.cpp) while the class definition is given in
header file (.h)
•Some authors also consider this as separation of
interface and implementation

Student.h
class Student{
int rollNo;
public:
int getRollNo();
…
};

Student.cpp
#include “student.h”
void Student::setRollNo(int aNo){
…
}
int Student::getRollNo(){
…
}

Driver.cpp
#include “student.h”
int main(){
Student aStudent;
}

Classes, Objects and Memory
• you might have the impression that each object created
from a class contains separate copies of that class’s data
and member functions.
• It’s true that each object has its own separate data items
• But all the objects in a given class use the same member
functions.
• The member functions are created and placed in memory
only once—when they are defined in the class definition.
• Since the functions for each object are identical. The data
items, however, will hold different values.

References
[www.nu.edu.pk]

Thanks

CSC241:
Object Oriented
Programming
Spring 2013
1. Static class member
2. Const member function
Farhan Aadil

static class member
• What is a static variable? What is its scope (local, file)
and storage class (automatic, static).
• What if a data member is static?
• A member variable defined as static has characteristics
similar to a normal static variable: It is visible only
within the class, but its lifetime is the entire program.
• It continues to exist even if there are no objects of the
class.
• Why would we need a static member data?

static class member data
class foo {
private:
static int count; //note: “declaration” only!
public:
foo() //incr count when object created
{ count++;
}
int getcount() //returns count
{ return count;
}
};
int foo::count = 0; //*definition* of count
int main()
{
foo f1, f2, f3; //create three objects
cout << “count is “ << f1.getcount()
<< endl; //each object
<< endl; //sees the
<< endl; //same value
return 0;
}

static class member
• For multiple objects of the same class, new memory is
allocated for data members and shared memory for all
the functions.
• This shared memory is also used for static data
members.
• Static data member requires two separate statements
for:
• Declaration (compiler is told about type and name)
• Definition (compiler sets aside memory)

static class member
• Why this two-part approach?
• If static member data were defined inside the class (as it
actually was in early versions of C++), it would violate the
idea that a class definition is only a blueprint and does not
set aside any memory.
• Putting the definition of static member data outside the
class also serves to emphasize that the memory space for
such data is allocated only once, before the program starts
to execute,
• and that one static member variable is accessed by an
entire class; each object does not have its own version of
the variable, as it would with ordinary member data.
• In this way a static member variable is more like a global
variable.

static class member
• Be careful:
• It’s easy to handle static data incorrectly, and the compiler is
not helpful about such errors.
• If you include the declaration of a static variable but forget its
definition, there will be no warning from the compiler.
• Everything looks fine until you get to the linker, which will tell
you that you’re trying to reference an undeclared global
variable.
• This happens even if you include the definition but forget the
class name (the foo:: in the example above).

Variable packing in memory
• If you do a ‘sizeof(class_obj_or_name)’ for an object of
a class/struct or class/struct name, you get the size of
the memory allocated for data members.
• Memory alignment in class/struct is a bit different.

Data member packing in
class/struct
class Counter
{
private:
unsigned char count;
unsigned char temp2;
short temp1;
int temp;
static int obj;
public:
Counter() : count(0)
{
}
}May 25, 2013 COMSATS Intitute of Information Technology 334
int sz = sizeof(Counter);
OR
Counter c1;
int sz = sizeof(c1);
Gives sz = 8
If there was no temp2, sz will still be 8.
If there was no temp1, sz will still be 8.
If rearranged, sz will change.
Experiment at home and make concepts.

const Member Functions
•There are functions that are meant to be
read only
•There must exist a mechanism to detect
error if such functions accidentally change
the data member

Example
bool Student::isRollNo(int aNo){
if(rollNo = = aNo){
return true;
}
return false;
}

Example
bool Student::isRollNo(int aNo){
/*undetected typing mistake*/
if(rollNo = aNo){
return true;
}
return false;
}

Example
bool Student::isRollNo
(int aNo)const{
/*compiler error*/
if(rollNo = aNo){
return true;
}
return false;
}

•Keyword const is placed at the end of the
parameter list

Declaration:
class ClassName{
ReturnVal Function() const;
};
Definition:
ReturnVal ClassName::Function() const{
…
}

Example
class Student{
public:
int getRollNo() const {
return rollNo;
}
};

const Functions
•Constant member functions cannot modify the
state of any object
•They are just “read-only”
•Errors due to typing are also caught at compile
time

const Functions
•Constructors and Destructors cannot be const
•Constructor and destructor are used to modify
the object to a well defined state

Example
class Time{
public:
Time() const {} //error…
~Time() const {} //error…
};

const Function
•Constant member function cannot change
data member
•Constant member function cannot access
non-constant member functions

Example
class Student{
char * name;
public:
char *getName();
void setName(char * aName);
int ConstFunc() const{
name = getName();//error
setName(“Ahmad”);//error
}
};

References
[www.nu.edu.pk]

Thanks

CSC241:
Object Oriented
Programming
Spring 2013
1. Arrays & String (Chapter
7)
Farhan Aadil

Arrays
 In everyday life we commonly group similar
objects into units. We buy eggs by the carton.
 In computer languages we also need to group
together data items of the same type. The most
basic mechanism that accomplishes this in C++
is the array.
 Arrays can hold a few data items or tens of
thousands. The data items grouped in an array
can be simple types such as int or float, or
they can be user-defined types such as
structures and objects.
 An array groups items of the same type. The
items in a in an array are accessed by an
index number. Using an index number to specify
an item allows easy access to a large number
of items.

Defining, Reading and Writing Array
// gets four ages from user, displays them
#include <iostream>
int main(){
int age[4], j; //array 'age' of 4 ints
for(j=0; j<4; j++){ //get 4 ages
cout << "Enter an age: ";
cin >> age[j]; //access array element
}
for(j=0; j<4; j++){ //display 4 ages
cout << "age[" << j << "] = " << age[j] << endl;
cout <<"Address " << &age[j] << " = " << age[j] <<
endl;
}
}

Calculating Average
#include <iostream>
int main(){
double avg, sum = 0 ;
int i ; int marks[10] ; /* array declaration */
for ( i = 0 ; i <= 9 ; i++ ){
cout << "nEnter marks ";
cin >> marks[i]; /* store data in array */
}
for ( i = 0 ; i <= 9 ; i++ )
sum = sum + marks[i] ; /* read data from
array*/
avg = sum / 10 ;
cout << "n Average marks = " << avg <<endl;
}

Using Direct Access on an Array
// Using Direct Access on Array
#include <iostream>
int main(){
int mem[]={50,60,70} ; // Initialize the array
cout << "mem[0] = " << mem[0] << endl;
cout << "mem[1] = " << mem[1] << endl;
cout << "mem[2] = " << mem[2] << endl;
mem[0] = 80;
mem[1] = 90;
mem[2] = 100;
cout << endl;
cout << "mem[0] = " << mem[0] << endl;
cout << "mem[1] = " << mem[1] << endl;
cout << "mem[2] = " << mem[2] << endl;
}

Printing in Reverse Order
#include <iostream>
int main(){
const int SIZE=5; // defines the size N for 5 elements
double a[SIZE]; // declares the array‟s elements as
type double
cout << "Enter " << SIZE << " numbers:t";
for (int i=0; i<SIZE; i++)
cin >> a[i];
cout << "In reverse order: ";
for (int i=SIZE-1; i>=0; i--)
cout << " " << a[i];
}

Out of Bounds
#include <iostream>
int main(){
float a[] = { 22.2,44.4, 66.6 };
float x=11.1;
cout << "I m going to Crash " << endl;
cin >> x;
a[3333] = 88.8; // ERROR: index is out of bounds!
return 0;
}

Passing Array to Function
#include <iostream>
int sum(int[],int); // declaration
int main(){
int a[] = { 11,33, 55,77 };
int size = sizeof(a)/sizeof(int);
cout << "sum(a,size) = " << sum(a,size) << endl;
cout << endl << a[0] << endl;
}
int sum(int a[],int n){
int sum=0;
for (int i=0; i<n; i++)
sum += a[i];
a[0] = 100;
return sum;
}

n Dimensional Arrays
#include <iostream>
int main(){ const int row=2, col=3; int i,j;
int ary[row][col] = {
{11,12,13},
{21,22,23}
};
for(i=0 ; i< row ; i++){
for(j=0 ; j<col; j++){ cout << ary[i][j] << " ";}
cout << endl;
}
for(i=0 ; i< row ; i++){
for(j=0 ; j<col; j++){
cout << &ary[i][j] << "="<<ary[i][j]<<"t";}
cout << endl;}
return 0;
}

n Dimensional Arrays
0x22ff40 = 11
0x22ff44 = 12
0x22ff48 = 13
0x22ff4C = 21
0x22ff50 = 22
0x22ff54 = 23
ary[0][0]=
ary[0][1]=
ary[0][2]=
ary[1][0]=
ary[1][1]=
ary[1][2]=






232221
131211

2-Dimensional Arrays
#include <iostream>
int ary[row][col] = {
{11,12,13},
{21,22,23},
{31,32,33} };
for(i=0 ; i< row ; i++){
for(j=0 ; j<col; j++){ cout << ary[i][j] << " ";}
cout << endl;
}
for(i=0 ; i< row ; i++){
cout << &ary[i][j] << "="<<ary[i][j]<<"t";}
cout << endl;}
}

3-Dimensional Arrays
0x22ff30 = 11
0x22ff34 = 12
0x22ff38 = 13
0x22ff3C = 21
0x22ff40 = 22
0x22ff44 = 23
ary[0][0]=
ary[0][1]=
ary[0][2]=
ary[1][0]=
ary[1][1]=
ary[1][2]=
0x22ff48 = 31
0x22ff4C = 32
0x22ff50 = 33
ary[2][0]=
ary[2][1]=
ary[2][2]=










333231
232221
131211

Calculating Square of a Matrix
#include <iostream>
int A[row][col];
cout << "Square of a " <<row <<"x"<<col<<"Matrices"<<endl;
for(i=0 ; i< row ; i++){
cout << "A[" << i+1 << "][" << j+1 << "]= ";
cin >> A[i][j];
}
}
for(i=0 ; i< row ; i++)
for(j=0 ; j<col; j++)
A[i][j] = A[i][j]*A[i][j];
for(i=0 ; i< row ; i++){
for(j=0 ; j<col; j++)
cout << A[i][j] << "t";
cout << endl;
}
return 0;
}

Passing 2D Array to Function
#include <iostream>
void get_data(float a[][3],int row, int col){
int i,j;
for (i=0; i<row; i++)
for (j=0; j<col; j++){
cout << "A["<<i+1<<"]["<<j+1<<"]:";
cin >> a[i][j];}
}
void show_data(float a[][3],int row, int col){
int i,j;
for (i=0; i<row; i++){
for (j=0; j<col; j++)
{cout << a[i][j] << "t";}
cout << endl; }
}
int main(){
float matrix[4][3]; // 4 rows and 3 columns
get_data(matrix,4,3);
show_data(matrix,4,3);
return 0;
}

Passing 3D Array to Function (1/2)
#include <iostream>
void get_data(float a[][3][2],int row, int col,int page){
int i,j,k;
for (k=0; k<page; k++){
cout <<"A["<< i <<"]["<< j <<"]["<< k <<"]:";
cin >> a[i][j][k];
} // end of for (j=0
} // end of for (i=0
} // end of for (k=0
}

Passing 3D Array to Function (2/2)
void show_data(float a[][3][2],int row, int col, int page){
int i,j,k;
for (k=0; k<page; k++){
cout << a[i][j][k] << "t";
}
cout << endl;
}
cout << endl;
}
}
int main(){
float matrix[4][3][2]; // 4 rows, 3 columns, 2 pages
get_data(matrix,4,3,2);
show_data(matrix,4,3,2);
system("PAUSE");
return 0;
}

Sorting Data Using Bubble Sort Algo
#include <iostream>
void print( float[], int );
void sort ( float[], int );
int main(){
int i; float data[10];
cout << "Enter 10 Numbers for Sorting n";
for( i=0 ; i<10 ; i++ ){
cout << "Enter No." <<i+1<< ":" ;
cin >> data[i];
}
sort(data,10);
print(data,10);
return 0;
}

Sorting Data Using Bubble Sort Algo
void sort( float a[], int n ){ // bubble sort:
for (int i=1; i<n; i++) // bubble up max{a[0..n-i]}:
for (int j=0; j<n-i; j++)
if (a[j] > a[j+1]){
float temp = a[j];
a[j]=a[j+1];
a[j+1] = temp;
}
}
void print( float a[], int n ){
cout << " Sorted Data is " << endl;
for (int i=0; i<n; i++)
cout << a[i] <<" ";
}

All in 1

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Ähnlich wie All in 1

Ähnlich wie All in 1 (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

All in 1