Oops concepts in c++ documentation

OOPS Concept in C++ programming Language 1
OOPS Concept in C++ Programming Language
Farouq Umar Idris
Introduction to Programming Logic (CIS142)
30/09/2013
Prof. R.K Sharma

ABSTRACT
OOPS concepts (object, class, encapsulation, abstraction, polymorphism and inheritance) have
tremendous programming consequences for programmers using structure languages. This project
shows how important oops concepts are in C++ and what the major difference between C
programming and C++ is. More importantly, it explains where and how to use the concepts (OOPS
concepts) by giving few self-explanatory examples. The entire project is solely based on the use of
OOPS concept in C++ and the difference between C++ and C programming.

Table of Contents
Acknowledgments......................................................................................................................4
Scope of project .........................................................................................................................4
Chapter 1: Introduction..............................................................................................................5
Objectives.............................................................................Error! Bookmark not defined.
Definition ...............................................................................................................................5
Difference between C Programming and C++ Based On Oops Concepts.............................6
CHAPTER 2: OPPS COMPONENTS.............................................Error! Bookmark not defined.
Object .....................................................................................................................................7
Class .....................................................................................................................................10
Example of class and object.................................................................................................11
Encapsulation .......................................................................................................................12
Data abstraction....................................................................................................................15
Difference between Encapsulation and Abstraction in Oops...............................................16
Conclusion ...............................................................................................................................17

ACKNOWLEDGMENTS
As a work group that we use to do in the end of a quarter, we can’t finish our work or write
our final project without expressing our great gratitude to MAII Stratford-university, that
throughout its managerial staff, by the work they are doing for education. Especially we give
also thanks to Professor R.K Sharma who led us during the course of introduction to
Programming and we come to end by giving also thanks to the entire group Member
Muhunga David Eleca, Farouq Umar Idris and Faso Mushigo Heritier.

1.0 INTRODUCTION
Definition
C programming is a general-purpose programming language developed between 1969 and
1973. Like most imperative languages in the ALGOL tradition, C has facilities for structured
programming and allows lexical variable scope and recursion, while a static type system
prevents many unintended operations. Its design provides constructs that map efficiently to
typical machine instructions, and therefore it has found lasting use in applications that had
formerly been coded in assembly language, most notably system software like the Unix
computer operating system.
C++ is a programming language that is general purpose, statically typed, free-form, multi-
paradigm and compiled. It is regarded as an intermediate-level language, as it comprises both
high-level and low-level language features. It was developed in 1979s and was originally
named C with Classes, adding object oriented features, such as classes, and other
enhancements to the C programming language.

DIFFERENCE BETWEEN C PROGRAMMING AND C++ BASED ON OOPS
CONCEPTS
First off, C++ is a non-procedural language but C programming is a totally procedural
language that doesn’t use the concepts of virtual functions in its programs. Polymorphism and
overloading concepts are also not applicable in C programming language but in C++
programming, virtual functions, polymorphism as well as operator overload are used. The
main difference between C programming and C++ is the concepts of OOPs that are used in
C++ and not in C programming.

2.0 OPPS CONCEPTS
2.1 Object
In fact, we are surrounded by objects. In fact, everything we know (almost) can be
considered as an object. The idea of object-oriented programming is handled in its source
code elements that are called "objects."
Imagine you want to create a complex application with many variables and functions that can
be called between them. At first view, it'll look like an experience of a scientist in which we
can’t understand anything as showed in the image below.
Sure you have created a set of code that is working but imagine that you want to publish it on
internet for everyone who wants to use it without to code again, they must be expert for
understanding directly what you have done, what function to call first, what value to send to
each function and so one. To discover all these things will take surly time, so that object

oriented programming became important, that is to say, all the staff represented by functions
and variables in our case will be made in a kind of cube; and this cube represent an object for
us. Let us illustrate by the image bellow.
Here, part of the cube (that represents an object) was deliberately set transparency to show
you that our chemical flasks (That represent functions and variables of our complex
application) are located inside the cube. But in reality, the cube is completely opaque; you
can’t see anything inside like represented in the next image.

Clearly: object-oriented programming so is to create the source code (possibly complex), but
that is masked by placing it inside a cube (representing an object) through which we see
nothing. For the programmer who will use it, he or she will work with a much simpler object
than before: he or she will just have to press buttons and to use it do not need a degree in
chemistry.
Briefly, we can define an object as a collection of functions and variables that has a name.

2.2 CLASS
Class is like a plan that describe object. We can compare it for example to a plan to build a
house.
The object is an instance of the class, that is to say, a concrete implementation of the plan. In
the above example, the object is the house. You can create several houses based on a
construction plan. We can therefore create multiple objects from a class.

Example of class and object
#include <iostream.h>
#include <conio.h>
Class Personage // creation of a class
{
int main()
{
Personnage david, goliath;
//Creation of 2 objets : david et goliath
goliath.attack(david); //goliath attack david
david.takePotionoflife(20); //david will take 20 of life in drinking a potion
goliath.attack(david); //goliath attack again david
david.attack(goliath); //david will do same
return 0;
}
}

2.3 ENCAPSULATION
Encapsulation can be defined as a method in which data and function are combined inside a
class. This process hides data and also protects it from being accessed from outside world or
unauthorised user. To access it, the user has to go through the functions within the class.
Encapsulation is a concept of object oriented programming which binds data and functions
together by manipulating the data and ends up keeping both the data and functions safe from
the outside world. With data encapsulation, data hiding came into existence. C++ generally
supports all properties of encapsulation and hiding data by the creation of a user defined
types which are referred to as classes. All items in C++ by default are private.
class Box
{
public:
doublegetVolume(void)
{
return length * breadth * height;
}
private:
double length; // this is the Length
double breadth; // this is the Breadth
double height; //and this, the Height
};

This means that access is restricted to only members of the class Box not to any other part of
a programme but just the class Box. By doing this, encapsulation is achieved. In order to
make them accessible by other members, we need to declare them public.
Example:
In C++ program where a class with public and private members are implemented are example
of example of data encapsulation and data abstraction.
#include <iostream.h>
class Adder{
public:
//this side of the programme is accessed by all
Adder(int x = 0)
{
total = x;
}
// this interface is all accessible by outside world
voidaddNum(int no)
{
total += no;
}
intgetTotal()
{
return total;
};
private:
// from here, data are hidden from outside world

int total;
};
int main( )
{
Adder y;
y.addNum(10);
y.addNum(20);
y.addNum(30);
cout<< "Total " <<y.getTotal() <<endl;
return 0;
}

2.4 DATA ABSTRACTION
Data abstraction can be considered as the process of showing only the essential part of a
program to the outside world and hiding the details. It is a process of representing only the
needed information within a program and leaving the details out. Data abstraction can be
considered also as the process or a technique used in separation of interface and
implementation.
For instance, in our television set that we use almost every day. We know how we can turn it
on and off, adjust the volume of the speaker and other external components of the television
set. But we have no idea how things inside the TV set work. How signals are sent and
received from where they are sent and how it modulates the signals. All this are not known by
us.
By this, it is seen that a television set is meant to separate its external interface from internal
implementation and we can do what we want with only the external part of it like change
channel and increase or decrease volume etc. This is a typical example of abstraction.
In terms of C++, classes are used to provide desired level of data abstraction. They provide
great level of public methods for the outside world or user to play with as well as
manipulating the object data and functionality of the object that is stating without knowing
how the class was implemented.

DIFFERENCE BETWEEN ENCAPSULATION AND ABSTRACTION IN OOPS
The two are a great deal in object oriented programming concepts and at some point are
interrelated.
1. Encapsulation simply means to hide something like in a capsule or something of that
nature. Therefore it is more like wrapping or simply hiding methods and properties.
Programmers use encapsulation in hiding data and codes within a single unit for the
purpose of protecting the data from outside world. Example of encapsulation is classes
while abstraction is the process of showing only what needs to be shown and hiding
details to the user. Abstraction as the name implies means abstract form of a thing. The
uses of abstraction arise in programming when we need to create an abstract class where
the abstract class represents properties of a class and methods.
2. Encapsulation is done by the use of protected and private access modifiers while
abstraction is done using abstract class and interface.
3. Integrity are enforced in OOPs by the use of encapsulation (i.e. making sure appropriate
use of data is done and in an appropriate manner), it is done by preventing programmers
access to data in an unintended manner.
4. Differentiation by example
Encapsulation
Class Encapsulation
{
Private float division;
Public float division
{
get { return division; }

set {division = value;}
}
}
Abstraction
abstract class Abstraction
{
public abstract void do Abstraction();
}
public class AbstractionImpl: Abstraction
{
public void doAbstraction()
{
// its Implemented it
}
}

2.5 INHERITANCE
Inheritance is one of main techniques used in OOOPS concept, that an Object gain the
proprieties of another without resetting to create a well-defined categories or class. This
technique also supports the hierarchical classification in which each object would not need to
be redefined by all its characteristics explicitly. It prevents the programmer's unnecessary
work and this is the concept of inheritance that does this job. Heritage gives us the
opportunity to object to inherit only the qualities that make it unique in its class. Generally it
can inherit all the attributes of its parent.
As we know there is:
1. Public Inheritance:
Is when a class is deriving from a public base class, the public members of the base class will
become the public members of the derived class and protected members of the base class
become protected members of the derived class. A base class's private members are never
accessible directly from a derived class, but can be accessed through calls to the public
and protected members of the base class.
2. Protected Inheritance:
Is when a deriving from a protected base class, public and protected members of the base
class become protected members of the derived class.
3. Private Inheritance:
Is when we deriving from a private base class, the public and the protected members of the
base class become private members of the derived class.

An example for better understanding.
Let specify that a class derives from another one, the class you create gain all the features of
the base class. If the derived class has some extra features but is otherwise the same as the
base class, this is a good oncoming.
access public protected private
Same class yes yes yes
Derived
classes
yes yes no
Outside classes yes no no
• • • •

#include <iostream>
// Base class
class Shape
{
public:
void setWidth(int w)
{
width = w;
}
void setHeight(int h)
{
height = h;
}
protected:
int width;
int height;
};
// Derived class
class Rectangle: public Shape
{

public:
int getArea()
{
return (width * height);
}
};
int main(void)
{
Rectangle Rect;
Rect. setWidth(5);
Rect. setHeight(7);
// Print the area of the object.
cout << "Total area: " << Rect.getArea() << endl;
return 0;
}

2.6 POLYMORPHISM
In 1967 Polymorphism was identified by Christopher Strachey then developed by Hindley
and Milner. The important thing is not the understanding of it implementation but how this
concept works. C++ programming language provide us two manners of retrieving the objects
and expression when the program is in the running process. Those two ways are Run time
and Compile time. The interesting fundamental idea in polymorphism is at the compile time,
the compiler doesn’t know which function to call before. But it’s done at time of running
(Run time).by other way the run time is called as late binding.
Example where a base class has been derived by other two classes:
#include <iostream>
class Shape {
protected:
int width, height;
public:
Shape( int a=0, int b=0)
{
width = a;
height = b;
}
int area()
{

cout << "Parent class area :" <<endl;
return 0;
}
};
class Rectangle: public Shape{
public:
Rectangle( int a=0, int b=0)
{
Shape(a, b);
}
int area ()
{
cout << "Rectangle class area :" <<endl;
return (width * height);
}
};
class Triangle: public Shape{
public:
Triangle( int a=0, int b=0)
{

Shape(a, b);
}
int area ()
{
cout << "Rectangle class area :" <<endl;
return (width * height / 2);
}
};
// Main function for the program
int main( )
{
Shape *shape;
Rectangle rec(10,7);
Triangle tri(10,5);
// store the address of Rectangle
shape = &rec;
// call rectangle area.
shape->area();
// store the address of Triangle

shape = &tri;
// call triangle area.
shape->area();
return 0;
}

3.0 CONCLUSION
OOPS is undoubtedly one of the most complicated programming techniques to explain. In
fact, it's a whole new way to see the programming rather than ‘technical’. Before
understanding OOPS, you must first understand what programming is.
At this time, the basic definition of the programming was as follows: a sequence of logical
instructions followed by the computer. In languages Object Oriented programming, the
emphasis is on data, or 'objects' used and how the programmer manipulates it. Actually with
OPPS concept, the program is now a solution to any problem that may be encountered, but
whatever it is developed in relation to the objects that define your problem and using the
functions associated with these objects.

Reference
1. Mark Allen Weiss, 2006, Data structures and algorithm analysis in C++ 3rd
edition
2. Henry C. Lucas jr. Information Technology for Management 7th
Edition
3. www.tutorialspot.edu
4. www.cplusplus.com

Oops concepts in c++ documentation

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Oops concepts in c++ documentation

Similar to Oops concepts in c++ documentation (20)

More from farouq umar

More from farouq umar (19)

Recently uploaded

Recently uploaded (20)

Oops concepts in c++ documentation