Object Oriented System

using C++
UNIT-1

BY: VIVEK DIMRI

OBJECT ORIENTED PARADIGM
Paradigm Common Features
Demonstrates feasibility of
representation of problem
Machine solutions within computers.
 “Problems can be  
Machine Instructions (“Op
solved by running a codes”)
program in a Data representations
computer.” Input
Output
 Paradigm Common Features
Improves readability of
Mnemonic (or computer programs by
Symbolic) using commands that
  looked words and numbers
“Programs should be that looked like numbers.
 
written in a manner Variable declarations
that makes them easily Assignment statements
understood by human Global scope of identifiers
Absolute, conditional jumps
beings.”
# Statement labels
# GOTO statements
Comments
 Paradigm Common Features
Simplify understandability
 Modular of programs by partitioning
  of large problems into
“Large programs should smaller problems that are
be composed of smaller more easily solved.
 
blocks of code.”
Subroutines, functions,
procedures
# Return statement
Formal/actual arguments
Separation of code/data
Local Scope of identifiers
Function libraries
 Paradigm Common Features
Improve readability of programs
 Structured by limiting the number of
  arbitrary ways in which
statements can be put together. 
“Proper programs Sequence
should be coded in a # Blocks
# Block scope of identifiers
way that minimizes the Selection
number of detours # If/Else statements
# Case/Switch statements
from the main flow of Iteration
the program.” # Do/For/While/Until
# Recursion
Exception handling
# Throw/Raise statements
# Catch statements
Controlled jumps
# Break/Continue/Cycle
 Paradigm Common Features
Simplifies programs by placing
  Object-oriented logically related parts close
  together and by having similar
“Programs should be parts of the program behave
written as a collection in a similar manner.
 
of otherwise Encapsulation
independent objects # Classes and objects
# Fields/Attributes
that interact with one # Methods
another.” Inheritance
# Constructors and Factories
Polymorphism
#
Interfaces/abstractions/pure
 Paradigm Common Features
Makes programs more
   Event-driven understandable by
 
implementing common
“Programs should be
frameworks and
written as responders conventions followed by
to external and internal all programmers.
stimuli.”
Events
Event generators
Event handlers
 Paradigm Common Features
Facilitates
    Visual communication between
 
programmers and users
“Programs should be
by using standard and
written by focusing on expected user-oriented
the interfaces first and components.
adding details later.”  
Visual
components/containers
Properties
Events
Structured versus Object oriented
development
Procedural Programming
Before Object Oriented Programming (OOP) was
popular, computer software was written in a
Procedural style.

This meant that the application/program was divided

into a large number of procedures. C is largely
procedural, and to a certain degree C++ and C# are
as well
 Structured Programming

Structured programming was first suggested by

Corrado Bohm and Guiseppe Jacopini.

The two mathematicians demonstrated that any

computer program can be written with just three
structures:
 Decisions
 Sequences
 loops
A popular design methodology was "Structured
Programming" but that has been rendered
obsolete by OOP
 Structured Programming

Structured programming (sometimes known as

modular programming) is a subset of procedural
programming that enforces a logical structure on
the program being written to make it more
efficient and easier to understand and modify.
Certain languages such as Ada, Pascal, and
dBASE are designed with features that
encourage or enforce a logical program
structure.
Often planned using a Top-down Design or
Hierarchy chart.
Procedure Program view
Main Program
Data

Procedure1 Procedure2 Procedure3

 Structured Programming

Focus is on procedures

All data is shared: no protection

More difficult to modify

Hard to manage complexity

 Object-Oriented Programming
Object-oriented programming is an approach that
provides a way of modularizing programs by creating
partitioned memory area for both data and functions
that can be used as templates for creating copies of
such modules on demand.

This means that an object is considered to be a

partitioned area of computer memory that stores
data and set of operations that can access the data.

Since the memory partitions are independent, the

objects can be used in a variety of different
programs without modifications

Object = Data + Methods (Functions)

 Object1
Data1+Procedures1

Object2

Data
Data2 + Procedures
Data12
Object3
Data3 + Procedures3

Object4

Data4 + Procedures4
Concept /Elements of OOPs
 Object
 Class
 Data abstraction and encapsulation
 Inheritance
 Polymorphism
 Dynamic Binding
 Message Passing
 OOP Basic Concepts/ Elements

Object:
An object is a concept, abstraction, or thing with identity
that has meaning for an application
All objects have identity and are distinguishable. For
example- Two apples with the same color, shape, and
texture are still individual apples
An object contains both data and methods that
manipulate that data
“Object” is an instance of a class. Each object has a
class which defines its data and behavior
Objects are the basic run-time entities in an object-
oriented system.
 OOP Basic Concepts/ Elements

Objects take up space in memory and have an

associated address like a record in Pascal, or a
structure in C.
When a program is executed, the objects interact
by sending messages to one another.
Object
Own copy of data
Active in running program
Occupies memory
Has the set of operations given in the class
Person
Age:34
 OOP Basic Concepts/ Elements

Class:
A class captures the common properties of
the objects instantiated from it
A class characterizes the common behavior
of all the objects that are its instances
Classes reflect concepts, objects reflect
instances that embody those concepts.
“Class” refers to a blueprint. It defines the
variables and methods the objects support
 OOP Basic Concepts/ Elements

Class:
Every object belongs to (is an instance of) a
class
An object may have fields, or variables
The class describes those fields
An object may have methods
The class describes those methods
A class is like a template, or cookie cutter
 OOP Basic Concepts/ Elements
Class
Employee

Name, designation
salary

Cal salary

Class employee
class class_name {
{ char name[20];
data types char desg[20];
member functions int salary;
}; public:
int calsalary()
(syntax of class) };
(Implementation of class)
 OOP Basic Concepts/ Elements

Encapsulation:
Wrapping up data methods in to a single unit
(class) is encapsulation. Data is accessible
only through its methods. (Protection))
Advantages of Encapsulation:
Protection
 Consistency
 Allows change
 OOP Basic Concepts

Data Abstraction:
Refers to the act of representing essential
features without including the background
details or explanations. (Classes use the
concept of abstraction and are defined as a
list of abstract attributes such as size, weight
and cost, and methods operate on these
attribute)
 OOP Basic Concepts

Inheritance:
The process by which object of one class
acquire the properties of objects another
class.
The sub-class inherits the base class’s data
members and member functions
A sub-class has all data members of its
base-class plus its own
A sub-class has all member functions of its
base class (with changes) plus its own
 OOP Basic Concepts

Animal

Mammal Reptile

Rodent Primate Cats

Mouse Squirel Rabbit

 OOP Basic Concepts

Polymorphism:
Ability to take more than one form. For ex. An
operation may exhibit different behavior in
different instances. The behavior depends upon
the type of data used in the operation.
For ex. The operation of addition. For numbers,
the operation will generate a sum and if the
operands are strings then the operation would
produce a third string by concatenation.
A single function name can be used to handle
different no and different arguments
 OOP Basic Concepts

Types of Polymorphism:

Compile Time
 Method overloading
 Operator overloading
Run Time
 Overriding
 virtual function
Dynamic Binding
 Binding refers to the linking of a procedure call to
the code to be executed in response to the call.
Dynamic binding (also known as late binding)
means that the code associated with a given
procedure call is not known until the time of the call
at run-time. It is associated with polymorphism and
inheritance. A function call associated with a
polymorphism reference depends on the dynamic
type of that reference.
Message Passing
 An object-oriented program consists of a set of objects that
communicate with each other. The process of programming in an
object-oriented language, therefore, involves the following basic
steps:
 Creating classes that define objects and their behavior,
 Creating objects from class definitions, and
 Establishing communication among objects.
 Objects communicate with one another by sending and receiving
information much the same way as people pass message to one
another. The concept of message passing makes it easier to talk
about building systems that directly model or simulate their real-
world counterparts.

 Example
 employee .salary (name);

 Object message infornation

 Advantage of OOP

simplicity: software objects model real world objects, so the

complexity is reduced and the program structure is very clear;

modularity: each object forms a separate entity whose

internal workings are decoupled from other parts of the system;

modifiability: it is easy to make minor changes in the data

representation or the procedures in an OO program. Changes
inside a class do not affect any other part of a program, since
the only public interface that the external world has to a class is
through the use of methods;

extensibility: adding new features or responding to changing

operating environments can be solved by introducing a few
new objects and modifying some existing ones;
 Advantage of OOP

maintainability: objects can be maintained separately,

making locating and fixing problems easier

re-usability: objects can be reused in different programs.

Provides a clear modular structure for programs. This

makes it good for defining abstract data types, where
implementation details are hidden and the unit has a clearly
defined interface.

Provides a good framework for code libraries, where

supplied software components can be easily adapted and
modified by the programmer. This is particularly useful for
developing graphical user interfaces.

Makes it easy to maintain and modify existing code, as new

objects can be created with small differences to existing ones.
 COMPARISON BETWEEN OOP &
STRUCTURED PROGRAMMING

Look through the graph above. For simple

or easy (even for semi hard) programs,
procedural approach can be a good solution.
 COMPARISON BETWEEN OOP &
STRUCTURED PROGRAMMING

But for the hard ones it is not.

On the other hand for simple problems,

approaching OOP concept is rather lengthy,
time consuming and not useful. It is however,
useful for tough problems.
 COMPARISON BETWEEN OOP &
STRUCTURED PROGRAMMING

 Procedural  Object Oriented

Withdraw, deposit, transfer Customer, money, account

 COMPARISON BETWEEN OOP &
STRUCTURED PROGRAMMING

OOP is easier to develop, debug, and maintain applications

then structured programming

The unit in procedural programming is function, and unit in

object-oriented programming is class

Procedural programming concentrates on creating functions,

while object-oriented programming starts from isolating the
classes, and then look for the methods inside them.

Procedural programming separates the data of the program

from the operations that manipulate the data, while object-
oriented programming focus on both of them
 Structure Object Oriented
1. It is function oriented. 1. It is data oriented.

2. Data & function are not 2. Data & function are

combined together. combined together.

3. Data is not secure. 3. Data is secure.

4. It follows top town 4. It follows bottom up

approach. approach.

5. New data &function can not 5. New data &function can

easily added. easily added.
INTRODUCTION TO C++
 History of C and C++
 History of C
 Evolved from two other programming languages
 CPL
 BCPL and B
 “Typeless” languages
 Dennis Ritchie (Bell Laboratories)
 C
 Added data typing, other features

 Extension of C
 Early 1980s: Bjarne Stroustrup (Bell Laboratories)
 C with class
 C++
 Provides capabilities for object-oriented programming
 Objects: reusable software components
 Model items in real world
 Object-oriented programs
 Easy to understand, correct and modify
 Compilation Model
Program is created in
Editor
Phases of C++ Programs: Disk the editor and stored
on disk.

Preprocessor program
1. Edit Preprocessor Disk
processes the code.
Compiler creates
2. Preprocess Compiler Disk object code and stores
it on disk.
Linker links the object
3. Compile Linker Disk code with the libraries,
creates a.out and
stores it on disk
4. Link Primary
Memory
Loader

5. Load Loader puts program

in memory.
Disk ..

6. Execute ..
..

Primary
Memory
CPU CPU takes each
 
instruction and
executes it, possibly
storing new data
..
.. values as the program
..
executes.
Program Hello
// This program is to print hello

#include <iostream>
using namespace std;

int main() {
cout <<"Hello!"<< endl;
return 0;
}
 Output & Input

cout << "Enter an integer: ";

 Output values to the screen
 Standard output stream (cout), or “see-out”
 Stream insertion operator (<<), or “put to”

cin >> int1;

 Obtain a value from the keyboard
 Standard input stream (cin), or “see-in”
 Stream extraction operator (>>), or “get from”
using namespace std;

This tells the compiler to use the std namespace.

Namespaces are a recent addition to C++.
A namespace creates a declarative region in which
various program elements can be placed.
Namespaces help in the organization of large
programs.
The using statement informs the compiler
that you want to use the std namespace. This is the
namespace in which the entire Standard C++ library
is declared. By using the std namespace you
simplify access to the standard library.
 Program Average
#include <iostream.h>
using namespace std;

int main() {
int x;
int y;
cout <<"Enter two numbers \n";
cin >> x >> y;
cout <<"Their average is: ";
cout << (x + y)/2.0 << endl;
return 0;
}
 Out put
Enter two numbers 8 10
Their average is: 9