Object oriented programming using c++

1
What is object-oriented paradigm?

3
Object-Oriented Programming
 Think from the perspectives of data (“things”)
and their interactions with the external world
Object
Data
Method: interface and message
Class
 The need to handle similar “things”
American, French, Chinese, Korean  abstraction
Chinese: northerners, southerners  inheritance
Dynamic binding, polymorphism

4
What OOP Allows You?
 You analyze the objects with which you are
working (attributes and tasks on them)
 You pass messages to objects, requesting them
to take action
 The same message works differently when
applied to the various objects
 A method can work with different types of data,
without the need for separate method names
 Objects can inherit traits of previously created
objects
 Information can be hidden better
(Object-Oriented Programming Using C++)

5
Outline
 The Concept of Abstraction (Sec. 11.1)
 Introduction to Data Abstraction (Sec. 11.2)
 Design Issues (Sec. 11.3)
 Language Examples (Sec. 11.4)
 Parameterized Abstract Data Types (Sec. 11.5)
 Encapsulation Constructs (Sec. 11.6)
 Naming Encapsulations (Sec. 11.7)

6
Abstraction
 Two types of abstractions:
Process abstraction: subprograms
Data abstraction
 Floating-point data type as data abstraction
The programming language will provide (1) a way of
creating variables of the floating-point data type, and
(2) a set of operators for manipulating variables
Abstract away and hide the information of how the
floating-point number is presented and stored
 Need to allow programmers to do the same
Allow them to specify the data and the operators

7
Abstraction Data Type
 Abstract data type: a user-defined data type
Declaration of the type and protocol of operations on
objects of the type, i.e., type’s interface, are defined
in a syntactic unit; interface indep. of implementation
Representation of objects of the type is hidden from
program units that use these objects; only possible
operations are those provided in type's definition
class data type int
object variable i, j, k
method operators +, -, *, /
y = stack1.top()+3; vs y = (-x) + 3;

8
Advantages of Data Abstraction
 Advantage of having interface independent of
object representation or implementation of
operations:
Program organization, modifiability (everything
associated with a data structure is together),
separate compilation
 Advantage of 2nd condition (info. hiding)
Reliability: By hiding data representations, user code
cannot directly access objects of the type or depend
on the representation, allowing the representation to
be changed without affecting user code

9
Language Requirements for ADTs
 A syntactic unit to encapsulate type definition
 A method of making type names and
subprogram headers visible to clients, while
hiding actual definitions
 Some primitive operations that are built into the
language processor
 Example: an abstract data type for stack
create(stack), destroy(stack), empty(stack),
push(stack, element), pop(stack), top(stack)
Stack may be implemented with array, linked list, ...

10
Outline

11
Abstract Data Types in C++
 Based on C struct type and Simula 67
classes
 The class is the encapsulation device
All of the class instances of a class share a single
copy of the member functions
Each instance has own copy of class data members
Instances can be static, stack dynamic, heap
dynamic
 Information hiding
Private clause for hidden entities
Public clause for interface entities
Protected clause for inheritance (Chapter 12)

12
Member Functions Defined in Class
class Stack {
private:
int *stackPtr, maxLen, topPtr;
public:
Stack() { // a constructor
stackPtr = new int [100];
maxLen = 99; topPtr = -1; };
~Stack () {delete [] stackPtr;};
void push (int num) {…};
void pop () {…};
int top () {…};
int empty () {…};
}
Implicitly inlined  code
placed in caller’s code

13
Language Examples: C++ (cont.)
 Constructors:
Functions to initialize the data members of instances
(they do not create the objects)
May also allocate storage if part of the object is heap-
dynamic
Can include parameters to provide parameterization
of the objects
Implicitly called when an instance is created
Can be explicitly called
Name is the same as the class name

14
Language Examples: C++ (cont.)
 Destructors
Functions to clean up after an instance is destroyed;
usually just to reclaim heap storage
Implicitly called when the object’s lifetime ends
Can be explicitly called
Name is the class name, preceded by a tilde (~)
 Friend functions or classes: to allow access to
private members to some unrelated units or
functions (see Section 11.6.4)
Necessary in C++

15
Uses of the Stack Class
void main()
{
int topOne;
Stack stk; //create an instance of
the Stack class
stk.push(42); // c.f., stk += 42
stk.push(17);
topOne = stk.top(); // c.f., &stk
stk.pop();
...
}

16
Member Func. Defined Separately
// Stack.h - header file for Stack class
class Stack {
private:
int *stackPtr, maxLen, topPtr;
public:
Stack(); //** A constructor
~Stack(); //** A destructor
void push(int);
void pop();
int top();
int empty();
}

17
Member Func. Defined Separately
// Stack.cpp - implementation for Stack
#include <iostream.h>
#include "Stack.h"
using std::cout;
Stack::Stack() { //** A constructor
stackPtr = new int [100];
maxLen = 99; topPtr = -1;}
Stack::~Stack() {delete[] stackPtr;};
void Stack::push(int number) {
if (topPtr == maxLen)
cerr << "Error in push--stack is fulln";
else stackPtr[++topPtr] = number;}
...

18
Abstract Data Types in Java
 Similar to C++, except:
All user-defined types are classes
All objects are allocated from the heap and accessed
through reference variables
Methods must be defined completely in a class
 an abstract data type in Java is defined and
declared in a single syntactic unit
Individual entities in classes have access control
modifiers (private or public), rather than clauses
No destructor  implicit garbage collection

19
An Example in Java
class StackClass {
private int [] stackRef;
private int maxLen, topIndex;
public StackClass() { // a constructor
stackRef = new int [100];
maxLen = 99; topPtr = -1;};
public void push (int num) {…};
public void pop () {…};
public int top () {…};
public boolean empty () {…};
}

20
An Example in Java
public class TstStack {
public static void main(String[] args) {
StackClass myStack = new StackClass();
myStack.push(42);
myStack.push(29);
System.out.println(“:“+myStack.top());
myStack.pop();
myStack.empty();
}
}

21
“Hello World!” Compared
(http://en.wikibooks.org/wiki/Hello_world_program)
C
#include <stdio.h>
int main(void){
print("Hello world!");
}
C++
#include <iostream>
using namespace std;
int main(){
cout<<"Hello World!"<<endl;
}
Java
public class HelloWorld {
public static void
main(String[] args){
System.out.println
("Hello world!");
}
}
Ruby
puts 'Hello, world!'
or
class String
def say
puts self
end
end
'Hello, world!'.say

22
Outline

23
Parameterized ADTs
 Parameterized abstract data types allow
designing an ADT that can store any type
elements (among other things): only an issue for
static typed languages
 Also known as generic classes
 C++, Ada, Java 5.0, and C# 2005 provide
support for parameterized ADTs

24
Parameterized ADTs in C++
 Make Stack class generic in stack size by
writing parameterized constructor function
class Stack {
...
Stack (int size) {
stk_ptr = new int [size];
max_len = size - 1; top = -1; };
...
}
Stack stk(150);

25
Parameterized ADTs in C++ (cont.)
 Parameterize element type by templated class
template <class Type>
class Stack {
private:
Type *stackPtr;
int maxLen, topPtr;
public:
Stack(int size) {
stackPtr = new Type[size];
maxLen = size-1; topPtr = -1; }
...
Stack<double> stk(150);
Instantiated by compiler

26
Outline

27
Generalized Encapsulation
 Enclosure for an abstract data type defines a
SINGLE data type and its operations
 How about defining a more generalized
encapsulation construct that can define any
number of entries/types, any of which can be
selectively specified to be visible outside the
enclosing unit
Abstract data type is thus a special case

28
Encapsulation Constructs
 Large programs have two special needs:
Some means of organization, other than simply
division into subprograms
Some means of partial compilation (compilation units
that are smaller than the whole program)
 Obvious solution: a grouping of logically related
code and data into a unit that can be separately
compiled (compilation units)
 Such collections are called encapsulation
Example: libraries

29
Means of Encapsulation: Nested
Subprograms
 Organizing programs by nesting subprogram
definitions inside the logically larger
subprograms that use them
 Nested subprograms are supported in Ada,
Fortran 95, Python, and Ruby

30
Encapsulation in C
 Files containing one or more subprograms can
be independently compiled
 The interface is placed in a header file
 Problem:
The linker does not check types between a header
and associated implementation
 #include preprocessor specification:
Used to include header files in client programs to
reference to compiled version of implementation file,
which is linked as libraries

31
Encapsulation in C++
 Can define header and code files, similar to
those of C
 Or, classes can be used for encapsulation
The class header file has only the prototypes of the
member functions
The member definitions are defined in a separate file
 Separate interface from implementation
 Friends provide a way to grant access to private
members of a class
Example: vector object multiplied by matrix object

32
Friend Functions in C++
class Matrix;
class Vector {
friend Vector multiply(const Matrix&,
const Vector&);
... }
class Matrix {
friend Vector multiply(const Matrix&,
const Vector&);
... }
Vector multiply(const Matrix& ml,
const Vector& vl) {
... }

33
Naming Encapsulations
 Encapsulation discussed so far is to provide a
way to organize programs into logical units for
separate compilation
 On the other hand, large programs define many
global names; need a way to avoid name
conflicts in libraries and client programs
developed by different programmers
 A naming encapsulation is used to create a new
scope for names

34
Naming Encapsulations (cont.)
 C++ namespaces
Can place each library in its own namespace and
qualify names used outside with the namespace
namespace MyStack {
... // stack declarations
}
Can be referenced in three ways:
MyStack::topPtr
using MyStack::topPtr; p = topPtr;
using namespace MyStack; p = topPtr;
C# also includes namespaces

35
 Java Packages
Packages can contain more than one class definition;
classes in a package are partial friends
Clients of a package can use fully qualified name,
e.g., myStack.topPtr, or use import declaration,
e.g., import myStack.*;
 Ada Packages
Packages are defined in hierarchies which
correspond to file hierarchies
Visibility from a program unit is gained with the with
clause

36
 Ruby classes are name encapsulations, but
Ruby also has modules
 Module:
Encapsulate libraries of related constants and
methods, whose names in a separate namespace
Unlike classes  cannot be instantiated or
subclassed, and they cannot define variables
Methods defined in a module must include the
module’s name
Access to the contents of a module is requested with
the require method

37
Ruby Modules
module MyStuff
PI = 3.1415
def MyStuff.mymethod1(p1)
...
end
def MyStuff.mymethod(p2)
...
end
end
Require ‘myStuffMod’
myStuff.mymethod1(x)

38
Summary
 Concept of ADTs and the use in program design
was a milestone in languages development
Two primary features are packaging of data with their
associated operations and information hiding
 C++ data abstraction is provided by classes
 Java’s data abstraction is similar to C++
 Ada, C++, Java 5.0, and C# 2005 support
parameterized ADTs
 C++, C#, Java, Ada, and Ruby provide naming
encapsulations

Object oriented programming using c++

More Related Content

What's hot (20)

Viewers also liked (13)

Similar to Object oriented programming using c++ (20)

More from Hoang Nguyen (20)

Recently uploaded (20)

Object oriented programming using c++

Editor's Notes