OODP Unit 1 OOPs classes and objects

OBJECT ORIENTED
DESIGN &
PROGRAMMING
1

UNIT I : INTRODUCTION TO
OOP
 Comparison of procedural programming and
Object-Oriented Programming
 OOPs and its features
 Data Types, Variables, static, constant, type
conversions
 Classes and objects
 Inline functions, friend functions
 Constructors and destructors
 UML Diagrams- Introduction, Class diagram and
its components
 Class diagram relations and its multiplicity
 UML use case diagram, use case , scenario 2

NEED OF OBJECT-ORIENTED
PROGRAMMING
Programming paradigm
Different approaches to build solutions to specific type of
problems
One problem-solving technique:
 Analyze the problem
 Outline the problem requirements
 Design steps (algorithm) to solve the problem
Algorithm:
 Step-by-step problem-solving process
 Solution achieved in finite amount of time
3

NEED OF OBJECT-ORIENTED
PROGRAMMING
4

STRUCTURED
PROGRAMMING
Structured programming (1960s)
 Disciplined approach to writing programs
 Clear, easy to test and debug, and easy to modify
Pascal
 1971: Niklaus Wirth
Ada
 1970s - early 1980s: US Department of Defense (DoD)
 Multitasking
 Programmer can specify many activities to run in
parallel
C Programming
5

THE KEY SOFTWARE TREND:
OBJECT TECHNOLOGY
Objects
 Reusable software components that model real
world items
 Meaningful software units
 Date objects, time objects, paycheck objects, invoice objects,
audio objects, video objects, file objects, record objects, etc.
 Any noun can be represented as an object
 More understandable, better organized and
easier to maintain than procedural
programming
 Favor modularity
 Software reuse
 Libraries 6

OBJECT ORIENTED
PROGRAMMING
Component of a program that knows how to
perform certain actions and how to interact with
other elements of the program
Features of OOP
 Bottom–up approach in program design
 Programs organized around objects, grouped
in classes
 Focus on data with methods to operate upon
object’s data
 Interaction between objects through functions
 Reusability of design through creation of new
classes by adding features to existing classes 7

PROCEDURAL VS. OBJECT-
ORIENTED
Procedural applicationOO-application
DATA
Line of code
Line of code
Line of code
Data is stored
independent
of application
Each object is independent of
the others
10

CHARACTERISTICS OF
OBJECT-ORIENTED
LANGUAGES
• Object
• Class
• Data Hiding and Encapsulation
• Dynamic Binding
• Message Passing
• Inheritance
• Polymorphism
Generic classes
11

CHARACTERISTICS OF OOP
Class– Basic building blocks OOP and a single
entity which has data and operations on data
together
Objects – The instances of a class which are used
in real functionality – its variables and operations
Abstraction – Specifying what to do but not how
to do ; a flexible feature for having a overall view
of an object’s functionality.
Encapsulation – Binding data and operations of
data together in a single unit – A class adhere this
feature
12

CHARACTERISTICS OF OOP
Polymorphism – Multiple definitions for a single
name - functions with same name with
different functionality; saves time in investing
many function names Operator and Function
overloading
Generic classes – Class definitions for
unspecified data. They are known as container
classes. They are flexible and reusable.
Class libraries – Built-in language specific
classes
Message passing – Objects communicates
through invoking methods and sending data to
them. This feature of sending and receiving
information among objects through function
parameters is known as Message Passing.
13

CLASSES & OBJECTS
Classes are templates that have methods
and attribute names and type information,
but no actual values!
Objects are generated by these classes and
they actually contain values.
We design an application at the class level.
When the system is running objects are
created by classes as they are needed to
contain state information.
When objects are no longer needed by the
application, they are eliminated.
14

EXAMPLE OF CLASSES AND
OBJECTS
15

EXAMPLE OF CLASSES AND
OBJECTS
16

CLASS & OBJECTS
Name
Number
CLASS: Furniture
methods: Example
ChangeNumber
Objects:
Desk
123445
ChairA
32143
ChairB
45687
17

INHERITANCE
Use in the small, when a derived class "is-a"
base class
enables code reuse
enables design reuse & polymorphic
programming
Example:
a Student is-a Person
Undergraduate
Person
Student Employee
Graduate Staff Faculty
18

SHAPE CLASS HIERARCHY
TwoDimensionalShape
Shape
ThreeDimensionalShape
Circle Square Triangle Sphere Cube Tetrahedron
19

POLYMORPHISM
Polymorphism is a property by which the
same message can be sent to objects of
several different classes and each object can
respond in a different way depending on its
class.
20

C++ PROGRAMMING
History of C++
 Extension of C
 Early 1980s: Bjarne Stroustrup (Bell Laboratories)
 Provides capabilities for object-oriented programming
 Objects: reusable software components
 Model items in real world
 Object-oriented programs
 Easy to understand, correct and modify
 Hybrid language
 C-like style
 Object-oriented style
 Both
21

STRUCTURE OF C++
PROGRAM
Declaration section includes different
library functions and header files. All
preprocessor directives are written in
this section.
Global declaration includes structure,
class, variable. All global variables are
declared here.
Main() function is an entry point for all
the function. Every C++ program starts
with main() function.
In C++, the semicolon is a statement
terminator.
C++ is a case-sensitive programming
language. (Thus, Name and
name are two different identifiers in
C++)
22

STRUCTURE OF C++
PROGRAM
Example : /* First C++ Program */
#include <iostream>
using namespace std;
int main()
{
cout<<"Welcome to SRM University";
return 0;
}
23

A SIMPLE PROGRAM: PRINTING A
LINE OF TEXT
Before writing the programs
Comments
Document programs
Improve program readability
Ignored by compiler
Single-line comment
Use C’s comment /* .. */ OR Begin with //
or
Preprocessor directives
Processed by preprocessor before
compiling
Begin with # 24

BASICS OF A C++ PROGRAM
Common Input/output functions
cin
Standard input stream
Normally keyboard
cout
Standard output stream
Normally computer screen
cerr
Standard error stream
Display error messages
25

BASICS OF C++ PROGRAM
/* First C++ Program */ /*...*/
comments are used for the
documentation to understand the code to
others. These comments are ignored by
the compiler
#include<iostream> It is a
preprocessor directive. It contains the
contents of iostream header file in the
program before compilation. This header
file is required for input output
statements.
26

STRUCTURE OF C++ PROGRAM
int/void Integer (int) returns a value. In the above
program it returns value 0. Void does not return a value so
there is no need to write return keyword.
main() It is an entry point of all the function where
program execution begins.
Curly Braces {...}It is used to group all statements
together.
std::cout. It is requried when we use #include . Std::cout
defines that we are using a name (cout) which belongs to
namespace std.
Namespace is a new concept introduced by ANSI where
C++ standard libraries are defined.
If using namespace std is placed into the program then it
does not required to write std:: throughout the code.
Namespace std contains all the classes, objects and
functions of the standard C++ library. 27

DATA TYPES
A type defines a set of values and a set of operations that can be
applied on those values. The set of values for each type is known as
the domain for the type.
Data types in C++ is mainly divided into two types:
Primitive Data Types: These data types are built-in or predefined
data types and can be used directly by the user to declare variables.
Primitive data types includes:
 Integer
 Character
 Boolean
 Floating Point
 Double Floating Point
 Valueless or Void
 Wide Character
 Also : String
Abstract or user defined data type: These data types are defined by
user itself. Like, defining a class in C++ or a structure.
28

DATA TYPES
Integer: Keyword used for integer data types is
int. Integers typically requires 4 bytes of memory
space and ranges from -2147483648 to
2147483647.
Character: Character data type is used for storing
characters. Keyword used for character data type
is char. Characters typically requires 1 byte of
memory
Boolean: Boolean data type is used for storing
boolean or logical values. A boolean variable can
store either true or false. Keyword used for
boolean data type is bool.
Floating Point: Floating Point data type is used for
storing single precision floating point values or
29

DATA TYPES
Double Floating Point: Double Floating Point data
type is used for storing double precision floating
point values or decimal values. Keyword used for
double floating point data type is double. Double
variables typically requires 8 byte of memory
space.
void: Void means without any value. void data
type represents a valueless entity. Void data type
is used for those function which does not returns
a value.
Wide Character: Wide character data type is also a
character data type but this data type has size
greater than the normal 8-bit datatype.
Represented by wchar_t. It is generally 2 or 4
30

DATA TYPES
Datatype Modifiers: As the name implies,
datatype modifiers are used with the built-in
data types to modify the length of data that a
particular data type can hold. Data type modifiers
available in C++ are:
Signed
Unsigned
Short
Long
31

The string Type
 a programmer-defined type
 requires #include <string>
A string is a sequence of characters
"Hi Mom"
"We're Number 1!"
"75607"
33

C++ PROGRAM USING DATA
TYPES
// C++ program to sizes of data types
#include<iostream>
int main()
{
cout << "Size of char : " << sizeof(char) << " byte" << endl;
cout << "Size of int : " << sizeof(int) << " bytes" << endl;
cout << "Size of short int : " << sizeof(short int) << " bytes"
<< endl;
cout << "Size of long int : " << sizeof(long int) << " bytes" <<
endl;
cout << "Size of signed long int : " << sizeof(signed long int)
<< " bytes" << endl;
cout << "Size of unsigned long int : " << sizeof(unsigned int)
<< " bytes" << endl;
cout << "Size of float : " << sizeof(float) << " bytes" <<endl;
cout << "Size of double : " << sizeof(double) << " bytes" <<
endl; 34

INPUT
Storing data in the computer's
memory requires two steps
1. Allocate the memory by
declaring a variable
2. Have the program fetch a value
from the input device and place
it in the allocated memory
location
35

CONSTANTS IN C++
Integer data(decimal, octal, hexa)
Floating point
Character
String
36

VARIABLES
A variable definition means to tell the
compiler where and how much to create the
storage for the variable.
38

VARIABLES
Rules for identifiers
must begin with letter or the
underscore _
followed by any combination of
numerals or letters
recommend meaningful identifiers
39

KEYWORDS - RESERVED
WORDS
C++ Keywords
Keywords common to the
C and C++ programming
languages
auto break case char const
continue default do double else
enum extern float for goto
if int long register return
short signed sizeof static struct
switch typedef union unsigned void
volatile while
C++ only keywords
asm bool catch class const_cast
delete dynamic_cast explicit false friend
inline mutable namespace new operator
private protected public reinterpret_cast
static_cast template this throw true
try typeid typename using virtual
wchar_t
40

DECLARATIONS
Constants and variables must be declared before
they can be used.
A constant declaration specifies the type, the name
and the value of the constant.
A variable declaration specifies the type, the name
and possibly the initial value of the variable.
When you declare a constant or a variable, the
compiler:
1. Reserves a memory location in which to store
the value of the constant or variable.
2. Associates the name of the constant or variable
with the memory location.
41

VARIABLE DECLARATIONS
Variables are used to store values that can be changed
during the program execution.
A variable is best thought of as a container for a value.
Syntax:
< type > < identifier >;
< type > < identifier > = < expression>;
Examples:
int sum; //single declaration
float p,q,r; //multiple declaration
char answer = 'y';
double temperature = -3.14;
42

A variable has a type and it can contain only values
of that type. For example, a variable of the type
int can only hold integer values.
Variables are not automatically initialized. For
example, after declaration
int sum;
the value of the variable sum can be anything
(garbage).
Thus, it is good practice to initialize variables when
they are declared.
Once a value has been placed in a variable it stays
there until the program deliberately alters it.
43

int i; // declared but not initialised
char c;
int i, j, k; // Multiple declaration
int i; // declaration
i = 10; // initialization
int i=10; //initialization and
declaration in same step
int i=10, j=11;
44

VARIABLE DECLARTION
#include <iostream>
int main ()
{
// Variable definition:
int a, b;
int c;
float f;
// actual initialization
a = 10;
b = 20;
c = a + b;
f = 70.0/3.0;
cout<<c<<endl<<f;
return 0;
}
45

SPECIAL TYPES OF VARIABLE
• Static - These variables holds their
value between function calls.
#include <iostream.h>
int main()
{
static int y=20;
}
46

CONSTANT DECLARATIONS
Constants are used to store values that never change
during the program execution.
Using constants makes programs more readable and
maintainable.
Syntax:
const <type> <identifier> = <expression>;
Examples:
const double PI = 3.14159;
const double US2HK = 7.8;
//Exchange rate of US$ to HK$
const double HK2TW = 3.98;
//Exchange rate of HK$ to TW$
const double US2TW = US2HK * HK2TW;
//Exchange rate of US$ to TW$ 47

CONSTANT VARIABLE
#include <iostream>
int main()
{
const int LENGTH = 10;
const int WIDTH = 5;
const char NEWLINE = 'n';
int area;
area = LENGTH * WIDTH;
cout << area;
cout << NEWLINE;
return 0;
}
48

CIN AND THE EXTRACTION
OPERATOR >>
A binary operator
Takes two operands
Name of an input stream on the left
cin for standard input from keyboard
Variable on the right
Variables can be "cascaded"
cin >> amount >> count >> direction;
Variables should generally be simple types
49

THE EXTRACTION OPERATOR
>>
Enables you to do input with the cin command
Think of the >> as pointing to where the data will end
up
C++ able to handle different types of data and multiple
inputs correctly
50

POINTERS
COMPUTER MEMORY
Each variable is assigned a memory slot (the size
depends on the data type) and the variable’s data
is stored there
Variable a’s value, i.e., 100, is
stored at memory location 1024
100
… … 1024 …
Memory address:
1024 1032
int a = 100;
…
1020
a
51

POINTERS
A pointer is a variable used to store the
address of a memory cell.
We can use the pointer to reference this
memory cell
100
… … 1024 …
Memory address:
1024
1032
…
1020
integer
pointer
52

POINTER TYPES
Pointer
C++ has pointer types for each type of
object
Pointers to int objects
Pointers to char objects
Pointers to user-defined objects
(e.g., Student, Complex)
pointers to pointers
Pointers to pointers to int objects
54

POINTER VARIABLE
Declaration of Pointer variables
type* pointer_name;
//or
type *pointer_name;
where type is the type of data pointed to (e.g. int, char,
double)
Examples:
int *n;
int **p; // pointer to pointer
55

ADDRESS OPERATOR &
The "address of " operator (&) gives the memory
address of the variable
 Usage: &variable_name
100
… … … …
Memory address: 1024
int a = 100; //get the value,
cout << a; //prints 100
//get the memory address
cout << &a; //prints 1024
…
1020
a
56

ADDRESS OPERATOR &
100
88 … … …
Memory address: 1024 1032
a
…
1020
b
#include <iostream>
void main(){
int a, b;
a = 88;
b = 100;
cout << "The address of a is: " << &a << endl;
cout << "The address of b is: " << &b << endl;
}
Result is:
The address of a is: 1020
The address of b is: 1024
57

POINTER VARIABLES
The value of pointer p is the address of variable a
A pointer is also a variable, so it has its own memory
address
100
88 … 1024 …
…
1020
a p
int a = 100;
int *p = &a;
cout << a << " " << &a <<endl;
cout << p << " " << &p <<endl;
Result is:
100 1024
1024 1032
58

POINTER TO POINTER
What is the output?
58 58 58
59

DEREFERENCING OPERATOR
*
We can access to the value stored in the variable
pointed to by using the dereferencing operator (*),
100
88 … 1024 …
…
1020
int a = 100;
int *p = &a;
cout << a << endl;
cout << &a << endl;
cout << p << " " << *p << endl;
cout << &p << endl;
Result is:
100
1024
1024 100
1032
a p
60

DON’T GET CONFUSED
Declaring a pointer means only that it is a pointer: int
*p;
Don’t be confused with the dereferencing operator,
which is also written with an asterisk (*). They are
simply two different tasks represented with the same
sign
int a = 100, b = 88, c = 8;
int *p1 = &a, *p2, *p3 = &c;
p2 = &b; // p2 points to b
p2 = p1; // p2 points to a
b = *p3; //assign c to b
*p2 = *p3; //assign c to a
cout << a << b << c;
Result is:?
61

A POINTER EXAMPLE
The code
void doubleIt(int x,
int * p)
{
*p = 2 * x;
}
int main(int argc, const
char * argv[])
{
int a = 16;
doubleIt(9, &a);
return 0;
}
Box diagram
Memory Layout
9
x
p
(8200)
x
(8196)
16
a
main
doubleIt
p
a
(8192)
16
9
8192
main
doubleIt
a gets 18 62

ANOTHER POINTER EXAMPLE
#include <iostream>
int main (){
int value1 = 5, value2 = 15;
int *p1, *p2;
p1 = &value1; // p1 = address of value1 : 1000
p2 = &value2; // p2 = address of value2 :1004
*p1 = 10; // value pointed to by p1=10 : 1000  10
*p2 = *p1; // value pointed to by p2= value pointed to by p1 1004->10
p1 = p2; // p1 = p2 (pointer value copied) p1 1004
*p1 = 20; // value pointed to by p1 = 20 100420
cout << "value1==" << value1 << "/ value2==" << value2;//Val1=10,Val2=20
return 0;
}
Let’s figure out:
value1==? / value2==?
Also, p1=? p2=?
63

REFERENCE VARIABLES
A reference is an additional name to
an existing memory location
9
x
ref
Pointer:
9
x
ref
Reference:
int x=9;
int *ref;
ref = &x;
int x = 9;
int &ref = x;
65

REFERENCE VARIABLES
A reference variable serves as an alternative
name for an object
int m = 10;
int &j = m; // j is a reference variable
cout << “value of m = “ << m << endl;
//print 10
j = 18;
cout << “value of m = “ << m << endl;
// print 18
66

REFERENCE VARIABLES
A reference variable always refers to
the same object. Assigning a
reference variable with a new value
actually changes the value of the
referred object.
Reference variables are commonly
used for parameter passing to a
function
67

TRADITIONAL POINTER
USAGE
void IndirectSwap(char *Ptr1, char *Ptr2)
{
char temp = *Ptr1;
*Ptr1 = *Ptr2;
*Ptr2 = temp;
}
int main() {
char a = 'y';
char b = 'n';
IndirectSwap(&a, &b);
cout << a << b << endl;
return 0;
}
68

PASS BY REFERENCE
void IndirectSwap(char& y, char& z)
{
char temp = y;
y = z;
z = temp;
}
int main() {
char a = 'y';
char b = 'n';
IndirectSwap(a, b);
cout << a << b << endl;
return 0;
}
69

TYPE CONVERSIONS
C++ facilitates type conversion into 2 forms :
Implicit Type Conversion - performed by the compiler
without programmer’s intervention.
The C++ compiler converts all operands upto the type of
the largest operand, which is called type promotion.
Explicit Type Conversion
Explicit conversion can be done using type cast operator
and the general syntax for doing this is :
datatype (expression);
70

IMPLICIT TYPE CONVERSION
 Done by the compiler on its own, without any external
trigger from the user.
 Generally takes place when in an expression more than
one data type is present. In such condition type
conversion (type promotion) takes place to avoid lose
of data.
 All the data types of the variables are upgraded to the
data type of the variable with largest data type.
71

EXPLICIT TYPE
CONVERSIONS
73
Converting by assignment: This is done by
explicitly defining the required type in front of
the expression in parenthesis. This can be also
considered as forceful casting.
Syntax: (type) expression;

TYPE CAST OPERATOR
C++ permit explicit type conversion of variables or
expressions using the type cast operator.
o (type-name) expression // C notation
o type-name ( expression ) // C++ notation
// like a function call
// notation
eg:- average = sum /(float) i; // C notation
average = sum / float(i); // C++ notation
74

TYPE CAST OPERATOR
p = int * ( q ); // is illegal
p = ( int * ) q; // is legal
Alternatively, we can use typedef to create an identifier of
the required type.
typedef int * int_pt;
p = int_pt ( q );
continue…
The type name should
be an identifier
75

TYPE CONVERSIONS
we have four specific casting operators:
static_cast <new_type> (expression)
const_cast <new_type> (expression)
dynamic_cast <new_type> (expression)
reinterpret_cast <new_type> (expression)
76

SCOPE OF VARIABLES
• Global Variables
• Local variables
include <iostream>
int x; // Global variable
declared
int main()
{
int a; // Local variable
declared
x=10; // Initialized once
cout <<"first value of x =
"<< x;
x=20; // Initialized again
a=10; // Initialized once
cout <<"Initialized again
with value = "<< x;
}
77

SCOPE RESOLUTION
OPERATOR
C++ is a block
structured language.
The scope of a
variable extends from
the point of its
declaration till the end
of the block
containing the
declaration. A variable
declared inside a
block is said to be
local to that block.
………
………
{
int x = 10;
………
………
}
………
………
{
int x = 1;
………
………
}
78

SCOPE RESOLUTION
OPERATOR
Blocks in C++ are often nested.
In C, the global version of a variable can not be
accessed from within the inner block.
C++ resolved this problem with the use of the
scope resolution operator ( :: ).
………
………
{
int x = 10;
……… Block1
………
{
int x = 1;
……… Block 2
………
}
………
………
}
continue…
79

SCOPE RESOLUTION
OPERATOR
The scope resolution operator ( :: ) can be
used to uncover a hidden variable.
: : variable-name
This operator allows access to the global
version of a variable.
continue…
80

SCOPE RESOLUTION OPERATOR
continue…
#include<iostream.h>
#include<conio.h>
int m = 10;
void main( )
{
int m = 20;
clrscr( );
cout << "m_local = " << m << "n";
cout << "m_global = " <<::m << "n";
getch( );
}
m_local = 20
m_global = 10
81

MEMORY MANAGEMENT
OPERATORS
malloc( ) and calloc( ) functions are used to
allocate memory dynamically at run time.
The function free( ) to free dynamically the
allocated memory.
The unary operators new and delete perform
the task of allocating and freeing the memory.
C
&
C++
C++
82

MEMORY MANAGEMENT
OPERATORS
o new to create an object
o delete to destroy an object
A data object created inside a block with new,
will remain in existence until it is explicitly
destroyed by using delete.
Thus the life time of an object is directly
under our control and is unrelated to the
block structure of the program.
continue…
83

The data-type
may be any
valid data
type
MEMORY MANAGEMENT
OPERATORS
o new to create an object
continue…
pointer-
variable is a
pointer of type
data-type
The new operator allocates
sufficient memory to hold a data
object of type data-type and
returns the address of the object
pointer-variable = new data-type;
The pointer-variable holds the
address of the memory space
allocated 84

MEMORY MANAGEMENT
OPERATORS
o pointer-variable = new data-type;
p = new int; // p is a pointer of type int
q = new float; // q is a pointer of type float
Here p and q must have already been declared
as pointers of appropriate types.
Alternatively, we can combine the declaration of
pointers and their assignments as:
int *p = new int;
float *q = new float;
continue…
85

MEMORY MANAGEMENT
OPERATORS
int *p = new int;
float *q = new float;
*p = 25; // assign 25 to the newly created int
object
*q = 7.5; // assign 7.5 to the newly created float
object
continue…
pointer-variable = new data-type (value);
int *p = new int ( 25 );
float *q = new float ( 7.5 );
86

MEMORY MANAGEMENT
OPERATORS
o delete to destroy an object
continue…
delete pointer-variable;
When a data object is no longer needed, it is
destroyed to release the memory space for
reuse.
delete p;
delete q;
delete [ size ] pointer-variable;
The size specifies the number of elements in the
array to be freed.
delete [ ]p; // delete the entire array pointed to
by p 87

MANIPULATORS
Manipulators are operators that are used to format the data
display.
Commonly used manipulators are:
o endl // causes a line feed when used in an
// output statement
o setw // to specify field width and force the
// data to be printed right-justified
88

MANIPULATORS continue…
#include<iostream>
#includeiomanip>
void main( )
{
int m, n, p;
m = 2597;
n = 14;
p = 175;
cout <<setw(10) << "First = " <<setw(10) << m << endl
<<setw(10) << "Second = " << setw(10) << n << endl
<<setw(10) << "Third = " << setw(10) << p << endl;
}
First = 2597
Second = 14
Third = 175
89

AN INTRODUCTION TO
CLASSES
Typically
 Programs will consist of
 Function main and
 One or more classes
 Each containing data members and member
functions
A class is a building block of OOP. It is the way to bind
the data and its logically related functions together.
An abstract data type/plan/blueprint that can be treated
like any other built in data type.
90

CLASS DEFINITION
Class head
Class body
class name_of_class
{ private:
data member( s);
member function(s);
public:
data member( s);
member function(s);
};
91

EXAMPLE
class test
{
private :
int a;
int b;
public:
void set_data(int x, int
y)
{
a=x;
b=y;
}
int big()
{
if (a > b)
return a;
else
return b;
}
};
Class declaration and
definition :
Does not allocate
memory
92

CHARACTERISTICS OF
ACCESS SPECIFIERS
(PRIVATE, PUBLIC AND
PROTECTED)
Private section of a class can have both data members and
member functions, usually data members are made private
for data security.
It is not mandatory that private section has to declared first in
the class and then the public section.
If no member access specifier is specified then by default the
members are private for the class.
There may be any number of private, public or protected
section in a class declaration.
Protected specifier is used for declaring the class members
which can be accessed by its own class and its derived class.
93

MEMBER FUNCTION
Member function’s name is visible outside the class.
It can be defined inside or outside the class.
It can have access to private, public and protected data
members of its class, but cannot access private data members
of another class.
•When defining a member function:
–Put prototype in class declaration
–Define function using class name and scope resolution operator
(::)
return-type ClassName::functionName parameters)
{
function-body;
}
94

INTRODUCTION TO OBJECTS
Object is an abstraction of real wold entity.
Objects are the variables/instances of
classes.
Syntax for declaring objects is as follows :
<class name> <obj_name1>,<obj_name2>,
…, <obj_name1>;
Example: for class test the objects can be
created as follows:
test t1,t2,…tn;
95

CHARACTERISTICS OF
OBJECTS:
It can have its own copy of data members.
The scope of an object is determined by the
place in which the object is defined.
It can be passed to a function like normal
variables.
The members of the class can accessed by
the object using the object to member access
operator or dot operator(.).
96

EXAMPLE
class test
{ private :
int a;
int b;
public:
void set_data(int x, int y)
{
a=x;
b=y;
}
int big() {
if (a > b) return a;
else return b;
}
};
void main()
{
test t;
int a,b;
cout<<“enter the two numbers”
<< endl;
cin>> a >> b;
t.set_data(a,b);
cout<<“the largest number is ”
<< t.big();
}
97

MORE ABOUT CLASSES
Its recommended to start the class name with an
uppercase letter.
If class name is made of more than one word,
then first letter of each word must be in
uppercase.
Example class Study
Class in C++ are similar to structures in C, the
only difference being, class defaults to private
access control, where as structure defaults to
public.
All the features of OOPS, revolve around classes
in C++. Inheritance, Encapsulation, Abstraction
etc. 98

ACCESS CONTROL IN
CLASSES
public
private
protected
These access specifiers are used to set boundaries for availability of
members of class be it data members or member function
Public : A public member is accessible from anywhere outside the
class but within a program.
private : A private member variable or function cannot be
accessed, or even viewed from outside the class. Only the class and
friend functions can access private members.
protected : A protected member variable or function is very similar
to a private member but it provided one additional benefit that they
can be accessed in child classes which are called derived classes
99

ACCESS SPECIFIERS
Private Members
Public Members
100

PRIVATE MEMBERS
Making data members private provides data protection
Data can be accessed only through public functions
Public functions define the class’s public interface
101

EXAMPLE FOR INT, FLOAT IN
CLASS
#include <iostream>
class temp
{
private:
int data1;
float data2;
public:
void int_data(int d){
data1=d;
cout<<"Number:
"<<data1;
}
float float_data(){
cout<<"nEnter data: ";
cin>>data2;
return data2;
}
};
int main(){
temp obj1, obj2;
obj1.int_data(12);
cout<<"You entered
"<<obj2.float_data();
return 0;
}
102

DEFINITION OF FUNCTION
OUTSIDE A CLASS.
The syntax for defining function outside a class is as
follows:
<data type> <class name> :: <function name>
()
{
// member function definition
}
Data type  return type
Class name  the class to which the member function
belongs.
Function name  name of member function.
103

ACCESS SPECIFIER -
ACCESSING PRIVATE DATA
OUTSIDE CLASS
104

EXAMPLE: MEMBER OUTSIDE
THE CLASS
Class test
{
private :
int a;
int b;
public:
void
set_data(int,int );
int big();
};
void test ::
set_data(int x, int
y)
{
a=x;
b=y;
}
int test :: big()
{
if (a > b)
return a;
Else
return b;
}
Main() as
given in
the
previous
program
105

#include <iostream>
#include <string>
class Student
{
string name;
int marks;
public:
void getName()
{
getline( cin, name );
}
void getMarks()
{
cin >> marks;
}
void displayInfo()
{
cout << "Name : " << name << endl;
cout << "Marks : " << marks << endl;
}
};
int main()
{
Student st[5];
for( int i=0; i<5; i++ )
{
cout << "Student " << i + 1 <<
endl;
cout << "Enter name" << endl;
st[i].getName();
cout << "Enter marks" << endl;
st[i].getMarks();
}
for( int i=0; i<5; i++ )
{
cout << "Student " << i + 1 <<
endl;
st[i].displayInfo();
}
return 0;
}
106

THE ARROW OPERATOR
(POINTER TO MEMBER)
It is also called as pointer to member access operator.
It is used when member functions or member data has
to access through a pointer which is pointing to an
object of a class.
Syntax for using arrow operator is :
Pointer_to_object -> class_member;
107

EXAMPLE OF ARROW
OPERATOR
Class test1
{
private :
int a;
int b;
public:
void add(int , int );
};
void test1 :: add(int x, int y)
{
a=x;
b=y;
return (a+b);
}
void main()
{
int sum;
test1 t;
sum = t.add(4,9)
cout<< sum << endl;
test1 *t1 = &t;
sum = t1 -> add(2,7);
cout<< sum<<endl;
}
Output:
13
9 // add called by pointer to
member
108

THIS OPERATOR
 It is a keyword used to store the address of the object
that invokes a member function.
 When each member function is invoked this pointer
implicitly holds the address of the object itself.
 It is defined internally.
 When an object is used to invoked a class member
function then the address of that object is
automatically assigned to the this pointer.
109

EXAMPLE SHOWING THE EXPLICIT USE
OF THIS POINTER :
#include<iostream>
class simple
{
int a;
public:
void set_data( int x)
{
this -> a = x;
}
void display()
{
cout<<this -> a<<endl;
cout<<“address of the object is =”<<
this<<endl;
}
};
void main()
{
simple s;
s.set_data(7);
s.display();
}
Output:
7
address of the object is =
0X8feeff4
110

PASSING OBJECTS AS
ARGUMENTS
Objects are passed to functions through the use of the
standard call-by-value mechanism.
Means that a copy of an object is made when it is
passed to a function.
111

OBJECT ASSIGNMENT
20, Shilpa
void read_data( )
void print_data( )
emp1
20, Shilpa
void read_data( )
void print_data( )
emp2
=
Only
If
Instanc
es of
same
Class!!
112

PASSING OBJECTS AS
ARGUMENTS
113

PASSING OBJECTS AS
ARGUMENTS
class complex
{
……
.…..
void Add(int x, complex c);
……
……
};
void main()
{
complex
obj, s1;
……
……
……
obj.Add(6,
s1) ;
……
…… 114

EXAMPLE int main()
{
Complex c1,c2,c3;
c1.Read();
c2.Read();
c3.Add(c1,c2);
c3.Display();
return 0;
}
Enter real and imaginary
Number :
12
3
Enter real and imaginary
Number :
2
6
Sum=14+9i
class Complex
{
private:
int real;
int imag;
public:
void Read()
{ cout<<"Enter real and imaginary
number”;
cin>>real>>imag; }
void Add(Complex comp1,Complex
comp2)
{ real=comp1.real+comp2.real;
imag=comp1.imag+comp2.imag;
}
void Display()
{
cout<<"Sum="<<real<<"+"<<imag<<"
i“; }
115

RETURNING OBJECTS FROM
FUNCTIONS
116

EXAMPLE
#include <iostream>
class Complex
{ private:
int real; int imag;
public:
void Read()
{ cin>>real>>imag; }
Complex Add(Complex
comp2)
{ Complex temp;
temp.real=real+comp2.real;
temp.imag=imag+comp2.i
void Display()
{
cout<<"Sum="<<real<<"+"<<imag<<"i";
}
};
int main()
{
Complex c1,c2,c3;
c1.Read();
c2.Read();
c3=c1.Add(c2);
c3.Display();
return 0;
}
117

WHY INLINE FUNCTIONS?
Objective of using functions:
 To save memory space, when a
function is likely to be called many
times.
 When a function is small enough
(only one line of code) these things
would be a wastage of time and
resources.
 Inline functions are commonly
used when the function definitions
are small, and the functions are
called several times in a program.
 Using inline functions saves time to
transfer the control of the program
from the calling function to the
definition of the called function.
Jumping to a function
Saving the registers
Pushing arguments in to
the stack
Returning to the calling
function
When a Function is
called:
118

INLINE FUNCTIONS
If a function is inline than:
 Compiler puts its code at the place where it is called at
compile time
 To define a function as inline function
 use the keyword “inline” just before the return type.
 The compiler ignore the inline qualifier in case defined
function is more than a line.
inline return_type function_name(args)
{
//one line code
}
119

WORKING OF INLINE
 The inline function is just a code replacement instead
of the function call.
 There is a need of stack storage and other special
mechanism for function call and return.
 The stack storage is used to store the return value and
return address for function call and return process.
 And while passing the parameter the stack storage
needed to store the parameter values, and from the
stack area the values moved to data area.
120

WORKINGS OF INLINE
 While using the inline function, there is no need of these
operations, because of code replacement.
 The compiler can do inline on either a high-level
intermediate representation or a low-level intermediate
representation.
 In either case, the compiler simply computes the
arguments, stores them in variables corresponding to the
function's arguments, and then inserts the body of the
function at the call site.
121

INLINE FUNCTIONS ADVANTAGES
 Function call overhead doesn’t occur.
 It saves the overhead of a return call from a function.
 It saves the overhead of push/pop variables on the stack when the
function is called.
 When we use the inline function it may enable the compiler to
perform context-specific optimization on the function body, such
optimizations are not possible for normal function calls.
 It increases the locality of reference by utilizing the instruction cache.
 An inline function may be useful for embedded systems because
inline can yield less code than the function call preamble and return.
123

INLINE FUNCTIONS LIMITATIONS
 The inline function must be simple and small.
 If the code size is too large, some compiler will not
treat that as inline function.
 The inline expansion can not be recognized by the
programmer. If the function is not treated as inline,
then it will take care of compiler as normal function.
124

In the following situation inline expansion may not work:
 For function returning values, if a loop, a switch or goto
exists.
 For function not returning values, if a return statement
exists.
 If function contains static variables.
 If inline function are recursive.
125

INLINE FUNCTION AND CLASSES
 It is also possible to define the inline function inside
the class.
 In fact, all the functions defined inside the class are
implicitly inline. Thus, all the restrictions of inline
functions are also applied here.
 If you need to explicitly declare inline function in the
class then just declare the function inside the class
and define it outside the class using inline keyword.
126

INLINE FUNCTION AND CLASSES
class S
{
public:
inline int square(int s)
{
// this function is automatically
inline
// function body
}
};
class S
{
public:
int square(int s);
// declare the function
};
inline int S::square(int s)
// use inline prefix
{
}
127

FRIEND FUNCTIONS AND FRIEND CLASSES
 If a function is defined as a friend function in C++,
then the protected and private data of a class can be
accessed using the function.
 By using the keyword friend compiler knows the given
function is a friend function.
 For accessing the data, the declaration of a friend
function should be done inside the body of a class
starting with the keyword friend.
128

HOW TO DECLARE?
Include its prototype in the class , preceding it with
keyword friend
Syntax:
friend ret_type func_name(arguments);
 Can be declared anywhere (in public, protected or private
section) in the class
 May have no arguments
 Objects of the class or their pointers can be passed as
arguments to the friend function
129

FEATURES OF FRIEND FUNCTIONS
 Not a member of the class
 Invoked like normal function without any object
 Full access to private and protected members of the
class
 But can use the members for one or more specific
objects
 Called without the use dot operator(does not need to be
qualified with object’s name)
130

USAGE OF FRIEND CLASSES
 As a function can be friend of more than one class, it can
be used for message passing between the classes.
 As it is not a member of the class ,it does not have a this
pointer. So can be used for Operator overloading. The
operands are passed explicitly to the overloaded friend
operator function.
 Make I/O functions easier
133

EXAMPLE: FUNCTION AS FRIEND OF MORE
THAN ONE CLASS
134

STATIC DATA MEMBERS AND FUNCTIONS
static data member a data member for which one copy is
shared by all objects of a class
Some common uses:
 A static member is simply declared with the reserved
word static.
 static function member a member function that can be
called independently of the existence of any class object
 Static member functions are only allowed to access data
members that are static. Why?
135

STATIC DATA MEMBERS
Declaration :
static data_type member_name;
Defining the static data member
It should be defined outside of the class following this
syntax:
data_type class_name :: member_name =value;
Accessing
class_name :: static_data_member;
136

STATIC DATA MEMBERS -PUBLIC
class Demo {
public:
static int ABC;
};
//defining
int Demo :: ABC =10;
int main()
{ cout<<"nValue of ABC: "<<Demo::ABC;
//accessing static data member
return 0; }
137

STATIC DATA MEMBER - PRIVATE
class Demo {
private:
static int X;
public:
static void fun()
{
cout <<" X: " << X << endl;
}
};
//defining
int Demo :: X =10;
int main() {
Demo X;
X.fun();
return 0;
}
138

STATIC MEMBER FUNCTIONS
 A static member function is a special member
function, which is used to access only static data
members,
To access :
 class_name:: function_name(parameter);
139

class stat {
int code;
static int count;
public:
void stat()
{ code = ++count; }
void showcode() {
cout << “Obj num:" << code;
}
static void showcount() {
cout << “Count Objects :" << count;
} };
int stat::count;
main() {
stat obj1, obj2;
obj1.showcount();
obj1.showcode();
obj2.showcount();
obj2.showcode();
}
Count Objects: 2
Obj Num: 1
Count Objects: 2
Obj Num is: 2
140

class IDGenerator
{ static int s_nextID
public:
static int getNextID() {
return s_nextID++;
} };
int IDGenerator::s_nextID = 1;
int main()
{ for (int count=0; count < 5; ++count)
cout << "The next ID is: “”;
cout<<IDGenerator::getNextID() << endl;
}
Output :
The next ID is: 1
The next ID is: 2
The next ID is: 3
The next ID is: 4
The next ID is: 5
141

OODP Unit 1 OOPs classes and objects

More Related Content

What's hot

Similar to OODP Unit 1 OOPs classes and objects

More from Shanmuganathan C

Recently uploaded

OODP Unit 1 OOPs classes and objects