Object-Oriented Programming
PROGRAMMING TECHNIQUES
• Unstructured programming• Procedural programming
• Modular programming
• Object-oriented programming
• Generic programming
UNSTRUCTURED PROGRAMMING
• Only one Program i.e. main Program• All the sequences of commands or statements in one programs called the main Program
• E.g. Fortran, assembly language, old Basic
MODULAR PROGRAMMING
• Procedures with some common functionality are grouped together into separate modules• Program is categorized into several smaller modules
• Each module can have its own data
Procedural Oriented Language
• Conventional programming, using a high-level language such as COBOL, FORTRAN, and C are commonly-known as Procedure oriented language (POP).• In POP numbers of functions are written to accomplish the tasks
 |
| Object Oriented Programming | Classes and Objects |
Procedure Oriented Language
- Characteristics -• Emphasis is on doing things (algorithms).
• Larger programs are divided into smaller
programs known as functions.
• Most of the functions share global data.
• Data move openly around the system from
function to function.
• Employs top-down approach in program design.
Procedural Oriented Language
- Limitations -
• Data move freely around the program and are
therefore vulnerable to changes caused by any
function in the program.
• It does not model very well the real world
problems.
Object Oriented Programming
• OOP treats data as critical element
• Ties data more closely to the functions that
operate on it & allows decomposition of
problem into objects.
OBJECT
Operations
Data
OBJECT OBJECT
Operations Operations
Data Communication Data
Santosh A. Darade, SITS, Narhe
Procedure Oriented Programming Object Oriented Programming
In POP, program is divided into small parts In OOP, program is divided into parts
Divided Into
called functions called objects
In POP, Importance is not given to data but to In OOP, Importance is given to the data rather
Importance functions as well as sequence of actions to be than procedures or functions because it works as a
done real world
Approach POP follows Top Down approach OOP follows Bottom Up approach
OOP has access specifiers named Public, Private,
Access Specifiers POP does not have any access specifier.
Protected, etc.
In POP, Data can move freely from function to In OOP, objects can move and communicate with
Data Moving
function in the system each other through member functions
To add new data and function in POP is not so OOP provides an easy way to add new data and
Expansion
easy function
In POP, Most function uses Global data for In OOP, data can not move easily from function
Data Access sharing that can be accessed freely from function to function, it can be kept public or private so we
to function in the system can control the access of data
POP does not have any proper way for hiding OOP provides Data Hiding so provides more
Data Hiding
data so it is less secure security
Examples Example of POP are : C, VB, FORTRAN, Pascal Example of OOP are : C++, JAVA, VB.NET, C#.NET
Fundamentals of OOP
• Objects
• Classes
• Encapsulation
• Data Abstraction
• Inheritance
• Polymorphism
• Dynamic Binding
• Message Passing
Objects
• OOP uses objects as its fundamental building
blocks.
• Objects are the basic run-time entities in an
object-oriented system.
• Every object is associated with data and
functions which define meaningful operations
on that object.
• Object is a real world existing entity.
• Object is an Instance of a particular class.
Object
Operation
Operation Attributes Operation
Operation
Example: StudentObject
Enroll()
st_name
st_id Displayinfo()
Performance()
branch
semester
Result()
Class
• Class is a collection of similar objects.
Class
Encapsulation
• It is a mechanism that associates the code and
the data & it manipulates into a single unit
and keeps them safe from external
interference and misuse.
Encapsulation
Class: student
Attributes: st_name, st_id,
branch, semester
Functions: Enroll()
Displayinfo()
Result()
Performance()
Data Abstraction
• A data abstraction is a simplified view of an
object that includes only features one is
interested in while hides away the
unnecessary details.
Inheritance
• Inheritance is the mechanism to provides the
power of reusability and extendibility.
• Inheritance is the process by which one object
can acquire the properties of another
object.
Inheritance
Parent class
Or
Base class
Point
Child class
Or
Derived
class Line
Polymorphism
• Polymorphism means that the same thing can
exist in two forms.
• Polymorphism is in short the ability to call
different functions by just using one type of
function call.
Polymorphism
5+9 Str + ing
+
22
Dynamic Binding
• Dynamic Binding is the process of linking of
the code associated with a procedure call at
the run-time
Message Passing
• The process of invoking an operation on an
object.
• In response to a message the corresponding
method is executed in the object
Message Passing
StudentObject FacultyObject
Performance
MgmtObject Performance
Result
USE OF C++
• C++ is used by hundreds of thousands of
programmers in essentially every application domain.
• C++ is being highly used to write device drivers and
other softwares that rely on direct manipulation of
hardware under real-time constraints.
• C++ is widely used for teaching and research because
it is clean enough for successful teaching of basic
concepts.
• Anyone who has used either an Apple Macintosh or a
PC running Windows has indirectly used C++ because
the primary user interfaces of these systems are26
written in C++.
C++ PROGRAM STRUCTURE
#include <iostream>// headers
using namespace std; // use std namespace
// main() is where program execution begins.
int main()
{
cout << "Hello World"; // prints Hello World//
// statements
return 0;
}
27
C++ IDENTIFIER
• A C++ identifier is a name used to identify a variable, function,
class, module, or any other user-defined item.
• Starts with a letter A to Z or a to z or an underscore (_)
followed by zero or more letters, underscores, and digits (0 to
9).
• C++ does not allow punctuation characters such as @, $, and %
within identifiers
• C++ is a case-sensitive programming language
• E.g. Mohd, zara, abc, move_name, a_123
myname50, _temp, j, a23b9, retVal
28
29
COMMENTS
• Program comments are explanatory statements that you can
include in the C++ code that you write and helps anyone reading
it's source code
• All programming languages allow for some form of comments.
• C++ supports single-line and multi-line comments
• C++ comments start with /* and end with */.
• /* This is a comment */
• /*
C++ comments can also
* span multiple lines
*/
• // prints Hello World ---single line comment 30
31
32
DATA TYPE PROGRAM
• #include <iostream>
• using namespace std;
• int main(){
cout << "Size of char : " << sizeof(char) << endl;
cout << "Size of int : " << sizeof(int) << endl;
cout << "Size of short int : " << sizeof(short int) << endl;
cout << "Size of long int : " << sizeof(long int) << endl;
cout << "Size of float : " << sizeof(float) << endl;
cout << "Size of double : " << sizeof(double) << endl;
cout << "Size of wchar_t : " << sizeof(wchar_t) << endl;
return 0;
} 33
// endl, which inserts a new-line character after every line
Variable Declaration
• A variable defines a location in the memory that
holds a value which can be modified later.
• Syntax:
type variable_list;
• In the above syntax "type" refers to any one of the
C++ data types.
Declaring Variables
• Variables in C++ should be declared before they are used in
the code block.
#include <iostream.h>
void main()
{
int n = 10;
cout << "Integer value is:"<< n << '\n';
}
• Result:
Integer value is: 10
In the above example "n" is an integer variable declared
using return type "int".
Rules for Naming variables in C++
• Always the first character of a variable must be a
letter or an underscore.
• The variable name cannot start with a digit.
• Other characters should be either letters, digits,
underscores.
• There is no limit for the length of variables.
• Declared keywords cannot be used as a variable
name.
• Upper and lower case letters are distinct.
Variable Scope
• A scope is a region of the program and broadly
speaking there are three places, where
variables can be declared:
– Inside a function or a block which is called local
variables,
– In the definition of function parameters which is
called formal parameters
– Outside of all functions which is called global
variables.
Local variables
• Parameters and variables declared inside the
definition of a function are local.
• They only exist inside the function body.
• Once the function returns, the variables no
longer exist!
Example Using Local Variables:
#include <iostream.h>
int main ()
{ // Local variable declaration:
int a, b;
int c;
// actual initialization
a = 10;
b = 20;
c = a + b;
cout << c;
return 0;
}
Global Variables
• We can declare variables outside of any
function definition – these variables are
global variables.
• Any function can access/change global
variables.
• Example: flag that indicates whether
debugging information should be printed.
Example Using Global and Local
Variables
#include <iostream>
// Global variable declaration:
int g;
int main ()
{ // Local variable declaration:
int a, b;
// actual initialization
a = 10;
b = 20;
g = a + b;
cout << g;
return 0;
}
Constants (const)
• Constants refer to fixed values that the
program may not alter
• Defining Constants:
• Using #define preprocessor.
• Using const keyword.
The #define Preprocessor:
• Following is the form to use #define preprocessor to define
a constant:
#define identifier value
Example
#include <iostream>
#define LENGTH 10
#define WIDTH 5
#define NEWLINE '\n'
int main()
{ int area;
area = LENGTH * WIDTH;
cout << area;
cout << NEWLINE;
return 0;
}
Result: 50
The const Keyword:
• use const prefix to declare constants with a specific type as
follows:
const type variable = value;
Example:-
#include <iostream.h>
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;
Output:50
}
Reference Variable
• Variable name as a label attached to the
variable's location in memory.
• Reference as a second label attached to that
memory location.
• Access the contents of the variable through
either the original variable name or the
reference.
• Syntax:
Data-type & reference name = variable name
• For example
int i = 17;
• We can declare reference variables for i as follows.
int& r = i;
the & in this declaration is as reference.
• Read declaration as "r is an integer reference
initialized to i"
Example
#include <iostream>
int main ()
{
// declare simple variables
int i; double d; Output:
// declare reference variables Value of i : 5
int& r = i; Value of i reference : 5
double& s = d; Value of d : 11.7
i = 5; Value of d reference : 11.7
cout << "Value of i : " << i << endl;
cout << "Value of i reference : " << r << endl;
d = 11.7;
cout << "Value of d : " << d << endl;
cout << "Value of d reference : " << s << endl;
return 0;
}
Comments in C++
• Program comments are explanatory
statements that you can include in the C++
code that you write and helps anyone reading
it's source code.
• C++ supports single-line and multi-line
comments. All characters available inside any
comment are ignored by C++ compiler.
• C++ comments start with /* and end with */.
For example:
/* This is a comment */
/* C++ comments can also
* span multiple lines
*/
• A comment can also start with //, extending to
the end of the line.
• For example:
#include <iostream.h>
main()
{
cout << "Hello World"; // prints Hello World
return 0;
}
Output : Hello World
Default Parameter
• C++ allows to call function without specifying
all its arguments
• Functions assigns default value to parameter
which does not have matching argument in
function call
• Specified when function is declared
Default parameter (Example)
Float amount(float principal, float period, float rate=0.15)
Default value 0.15 to parameter rate
Function call like
value = amount (5000,7); //one parameter missing
Passes 0.15 to rate
Now,
value =amount(5000,7,0.12) //no missing argument
Passes explicit value 0.12 to rate
#include<iostream.h> Output:
#include<conio.h> Enter Length:6
int vol(int=1,int=2,int=3); Enter width:5
main() { Enter height: 9
clrscr(); Volume with no argument passed =6
int length; int width; int height; Volume with one argument passed=36
int volume;
cout<<"\n Enter length = ";
cin>>length;
cout<<"\n Enter width = "; int vol(int l,int h,int w)
cin>>width; {
cout<<"\n Enter heigth = "; return l*h*w;
cin>>height; }
volume=vol();
cout<<"\n Volume with no argument passed ="<<volume;
volume=vol(length);
cout<<"\n Volume with one argument passed = "<<volume;
volume=vol(length,width);
getch();
return 0; }
C++ Functions
• Set of program statements that can be
processed independently.
• Like in other languages, called subroutines or
procedures.
Advantages …?
• Elimination of redundant code
• Easier debugging
• Reduction in the Size of the code
• Leads to reusability of the code
• Achievement of Procedure Abstraction
Function Prototype
• Is a declaration statement in program
• Syntax:
Return type function name (parameter list);
Sample function
ame Formal parameters
Return type Function n
int add_int(int a, int b)
{
return(a+b);
} Fun
ctio
n bo
dy
Function Overloading
Multiple functions to share the same name with
different signatures(types or numbers).
int myfunc(int i) int myfunc(int i, int j)
{ {
return i; return i*j;
} }
Inline Functions
• Disadvantages of using function
Every time a function is called, it take a lot of extra
time in executing a series of instructions.
In the following ways of execution it takes more
time
§ Jumping to the function
§ Saving in Register.
§ Pushing arguments into the stack.
§ Returning to the calling function.
Inline Functions
Inline functions are those whose function body is
inserted in place of the function call statement during
the compilation process.
• Syntax:
inline returntype func_name(formal parameters)
{
function body
}
Inline Functions
• Conditions for inline functions
– Function should not have any return statement
– Function should not be recursive
– Function length should be small
– Function should not contain static variable
Example
void main()
#include<iostream.h>
{
#include<conio.h>
line obj;
float val1,val2;
class line
clrscr();
{
cout<<"Enter two values:";
public:
cin>>val1>>val2;
inline float mul(float x,float y)
cout<<"\nMultiplication value is:“;
{
cout<<obj.mul(val1,val2);
return(x*y);
cout<<"\n\nCube value is:”;
}
inline float cube(float x)
cout<<obj.cube(val1)<<"\t"<<obj.cube(val2);
{
getch();
return(x*x*x);
}
}
};
Inline Function
• Advantages
Ø Shorter execution time
Ø Does not require function calling overhead
Ø Saves time
• Disadvantages
ØIncreases the length of file
ØMay make our file unreadable
C++ Overview
3/12/2020 Santosh A. Darade, SITS, Narhe 64
Structure of C++ Program
Include Files
Class Definition
Class Function Definition
Main Function Program
3/12/2020 Santosh A. Darade, SITS, Narhe 65
Simple C++ Program
// Hello World program comment
#include <iostream.h> Allows access to an I/O
library
int main() {
Starts definition of special function
main()
cout << "Hello World\n";
output (print) a
string
return 0;
Program returns a status
} code (0 means OK)
3/12/2020 Santosh A. Darade, SITS, Narhe 66
>> :- Input using Extraction operator
3/12/2020 Santosh A. Darade, SITS, Narhe 67
C++
Output using insertion
operator
3/12/2020 Santosh A. Darade, SITS, Narhe 68
3/12/2020 Santosh A. Darade, SITS, Narhe 69
3/12/2020 Santosh A. Darade, SITS, Narhe 70
Memory Management Operator
• New and delete operators are used to allocate
and free the memory
• Object can be created by using new and
deleted by using delete operator
• Syntax:
Pointer variable = new data-type
3/12/2020 Santosh A. Darade, SITS, Narhe 71
Example
Int *p=new int;
Float *q=new float;
• Suppose
*p=25
*q=7.5
3/12/2020 Santosh A. Darade, SITS, Narhe 72
• Data object no longer needed, it is destroyed
to release memory space for reuse.
• Syntax
delete pointer variable
Example :
delete q;
delete p;
3/12/2020 Santosh A. Darade, SITS, Narhe 73
Defining Class
3/12/2020 Santosh A. Darade, SITS, Narhe 74
Class Specification
• Syntax:
class class_name
{
Data members
Members functions
};
3/12/2020 Santosh A. Darade, SITS, Narhe 75
Class Specification
• class Student
{
int st_id; Data Members or Properties of
Student Class
char st_name[];
void read_data(); Members Functions or
Behaviours of Student Class
void print_data();
};
3/12/2020 Santosh A. Darade, SITS, Narhe 76
Class Specification
• Visibility of Data members & Member functions
Public –
Accessed by member functions and all other non-
member functions in the program.
Private –
Accessed by only member functions of the class.
Protected –
Similar to private, but accessed by all the member
functions of immediate derived class
Default –
All items defined in the class are private.
3/12/2020 Santosh A. Darade, SITS, Narhe 77
Class Specification
• class Student
{
int st_id;
char st_name[]; private / default
void read_data(); visibility
void print_data();
};
3/12/2020 Santosh A. Darade, SITS, Narhe 78
Class Specification
• class Student
{
public:
int st_id;
char st_name[];
public visibility
public:
void read_data();
void print_data();
};
3/12/2020 Santosh A. Darade, SITS, Narhe 79
Class Objects
• Object Instantiation:
The process of creating object of the type class
• Syntax:
class_name obj_name; of the
bj e c t
s ingle o
ex: Student st; Crea t e s
e Stude
a
nt!
typ
St_id, St_name
void read_data( )
void print_data( )
3/12/2020 Santosh A. Darade, SITS, Narhe 80
Class Object
• More of Objects
ex: Student st1;
Student st2;
Student st3;
3/12/2020 Santosh A. Darade, SITS, Narhe 81
Class Objects
10,Rama 20, Stephen
void read_data( ) void read_data( )
void print_data( ) void print_data( )
st1 st2
55, Mary
void read_data( )
void print_data( )
3/12/2020 st3
Santosh A. Darade, SITS, Narhe 82
Arrays of Objects
• Several objects of the same class can be
declared as an array and used just like an array
of any other data type.
• The syntax for declaring and using an object
array is exactly the same as it is for any other
type of array.
3/12/2020 Santosh A. Darade, SITS, Narhe 83
33, Joseph
Class Objects St[0]
• Array of )
void read_data( Objects S[0]
ex:print_data( ) Student s[8]; S[1]
void
S[2]
24, Sakshi S[3]
void read_data( )
S[4]
S[5]
void print_data( )
S[6]
St[4] S[7]
3/12/2020 Santosh A. Darade, SITS, Narhe 84
Accessing Data Members
(inside the class)
• Syntax: (single object)
data_member;
ex: st_id;
• Syntax:(array of objects)
data_member;
ex: st_id;
3/12/2020 Santosh A. Darade, SITS, Narhe 85
Accessing Data Members
(outside the class)
• Syntax: (single object)
obj_name . datamember;
ex: st.st_id;
• Syntax:(array of objects)
obj_name[i] . datamember;
ex: st[i].st_id;
3/12/2020 Santosh A. Darade, SITS, Narhe 86
Defining Member Functions
(Inside the class definition)
• Syntax
ret_type fun_name(formal parameters)
{
function body
}
3/12/2020 Santosh A. Darade, SITS, Narhe 87
Defining Member Functions
(Outside the class definition)
• Syntax
ret_type class_name::fun_name(formal parameters)
{
function body
}
3/12/2020 Santosh A. Darade, SITS, Narhe 88
Accessing Member Functions
• Syntax: (single object)
obj_name . Memberfunction(act_parameters);
ex: st.read( );
• Syntax:(array of objects)
obj_name[i] . Memberfunction(act_parameters);
ex: st[i].read( );
3/12/2020 Santosh A. Darade, SITS, Narhe 89
Inline Functions with Class
• Syntax: (Inside the class definition)
inline ret_type fun_name(formal parameters)
{
function body
}
3/12/2020 Santosh A. Darade, SITS, Narhe 90
Inline Functions with Class
• Syntax: (Outside the class definition)
inline ret_type class_name::fun_name (formal
parameters)
{
function body
}
3/12/2020 Santosh A. Darade, SITS, Narhe 91
Static Data Members
• Static data members of a class are also known
as "class variables“.
• Because their content does not depend on
any object.
• They have only one unique value for all the
objects of that same class.
3/12/2020 Santosh A. Darade, SITS, Narhe 92
Static Data Members
• Tells the compiler that only one copy of the
variable will exist and all objects of the class
will share that variable.
• Static variables are initialized to zero before
the first object is created.
• Static members have the same properties as
global variables but they enjoy class scope.
3/12/2020 Santosh A. Darade, SITS, Narhe 93
Static Member Functions
• Member functions that are declared with
static specifier.
Syntax:
class class_name
{
public:
static ret_dt fun_name(formal parameters);
};
3/12/2020 Santosh A. Darade, SITS, Narhe 94
Static Member Functions
Special features:
• They can directly refer to static members of
the class.
• They can be called using class name like..
• Class name::function name;
3/12/2020 Santosh A. Darade, SITS, Narhe 95
int main()
{
#include < iostream>
test t1,t2;
Class test
t1.setcode();
{
t2.setcode();
Int code;
test::showcount();
Static int count;
test t3;
Public:
t3.setcode();
Void setcode(void)
test::showcount();
{ code=++count;}
t1.showcode();
Void showcode(void)
t2.showcode();
{ cout<<“object no.:”<<code;}
t3.showcode(); Output
Static void showcount(void)
Return 0; Count:2
{ cout<<“count:”<<count; }
} Count :3
};
Int test::count; Object number:1
Object number:2
Object number:3
3/12/2020 Santosh A. Darade, SITS, Narhe 96
Constructors
• A constructor function is a special member
function that is a member of a class and has
the same name as that class, used to create,
and initialize objects of the class.
• Constructor function do not have return type.
• Should be declared in public section.
• Invoked automatically when objects are
created
3/12/2020 Santosh A. Darade, SITS, Narhe 97
Constructors
Syntax: Example:
class class_name class student
{
{ int st_id;
public:
class_name(); public:
}; student()
{
st_id=0;
}
3/12/2020
};
Santosh A. Darade, SITS, Narhe 98
Constructors
• How to call this special function…?
class student
{
int main() int st_id;
{ public:
student st; student()
………… {
………… st_id=0;
}; }
3/12/2020 Santosh A. Darade, SITS, Narhe }; 99
Types of Constructors
• Parameterized constructors
• Constructors with default argument
• Copy constructors
• Dynamic constructors
3/12/2020 Santosh A. Darade, SITS, Narhe 100
Parameterized Constructors
class Addition
{
eters
int num1; Cons t r u c to r with p
f u
a
n
r a m
ction!
o a
it’s als
int num2; B ’ C o z
int res;
public:
Addition(int a, int b); // constructor
void add( );
void print(); Constructor that can take
}; arguments is called
3/12/2020
parameterized constructor.
Santosh A. Darade, SITS, Narhe 101
Overloaded Constructors
class Addition
{
int num1,num2,res; ith
r u c t or w
Const
float num3, num4, f_res; Over l o a d e d
’C oz t h ey are
ters B
parame ions!
public: also fu n c t
Addition(int a, int b); // int constructor
Addition(float m, float n); //float constructor
void add_int( );
void add_float();
void print();
};
3/12/2020 Santosh A. Darade, SITS, Narhe 102
Constructors with Default Argument
class Addition
{
int num1; cto r w it h default
Constru
int num2; parame
ter.
int res;
public:
Addition(int a, int b=0); // constructor
void add( );
void print();
};
3/12/2020 Santosh A. Darade, SITS, Narhe 103
Copy Constructor
class code
int main()
{ { code A(100);
int id; code B(A);
public: code C=A;
code() //constructor code D;
D=A; // wrong syntax for copy
{ id=100;}
construcor
code(code &obj) // constructor cout<<“ id of A:”; A.display();
{ cout<<“ id of B:”; B.display();
id=obj.id; cout<<“ id of C:”; C.display();
} cout<<“ id of D:”; D.display();
}
void display() Copy constructor is used
{
cout<<id; to declare and initialize
} an object from another
}; object
3/12/2020 Santosh A. Darade, SITS, Narhe 104
Dynamic Constructors
Used to allocate memory at the time of object
creation
class Sum_Array
{
int *p;
public:
Sum_Array(int sz) // constructor
{
p=new int[sz];
}
3/12/2020
}; Santosh A. Darade, SITS, Narhe 105
Destructors
• A destructor function is a special function that
is a member of a class and has the same name
as that class used to destroy the objects.
• Must be declared in public section.
• Destructor do not have arguments & return
type.
NOTE:
A class can have ONLY ONE destructor
3/12/2020 Santosh A. Darade, SITS, Narhe 106
Destructors
Synatax: Example:
class class_name class student
{ {
public: public:
~class_name(); ~student()
}; {
cout<<“Destructor”;
}
};
3/12/2020 Santosh A. Darade, SITS, Narhe 107
Local Classes
• A class defined within a function is called
Local Class.
void fun()
Syntax: {
void function() class myclass {
{ int i;
class class_name public:
{ void put_i(int n) { i=n; }
// class definition int get_i() { return i; }
} obj; } ob;
//function body ob.put_i(10);
} cout << ob.get_i();
3/12/2020
}
Santosh A. Darade, SITS, Narhe 108
Multiple Classes
Synatax: Example: Example:
class class_name1 class test class student
{ { int st_id;
{ public: test m;
//class definition int t[3]; public:
}; }; viod init_test()
{
class class_name2
m.t[0]=25;
{ m.t[1]=22;
//class definition m.t[2]=24;
}; }
3/12/2020 Santosh A. Darade, SITS, Narhe }; 109
Nested Classes
Synatax: Example:
class student
class outer_class { int st_id;
{ public:
//class definition class dob
{ public:
class inner_class int dd,mm,yy;
{ }dt;
void read()
//class definition {
}; dt.dd=25;
dt.mm=2;
dt.yy=1988;}
}; };
3/12/2020 Santosh A. Darade, SITS, Narhe 110
Friend Functions
• Friend function is a non-member function
which can access the private members of a
class
• To declare a friend function, its prototype
should be included within the class, preceding
it with the keyword friend.
3/12/2020 Santosh A. Darade, SITS, Narhe 111
Friend Functions
Example:
class myclass
{
Syntax: int a, b;
class class_name public:
{ friend int sum(myclass x);
//class definition void set_val(int i, int j);
public: };
friend rdt fun_name(formal parameters);
};
3/12/2020 Santosh A. Darade, SITS, Narhe 112
Friend Function
• Characteristics:
• Not in the scope of class to which it has been
declared as friend
• It can not be called using object of class
• Invoked like normal function
• Can not access data members directly, has to
use object and dot operator
• Can be declare in private or public section.
• It has objects as arguments.
3/12/2020 Santosh A. Darade, SITS, Narhe 113
Void max (XYZ m,ABC
#include<iostream> n)
Class ABC; {
Class XYZ If(m.x>=n.a)
{ int x; Cout<<m.x;
Public: Else
Void setvalue(int i) {x=i;} Cout<<n.a;
Friend void max(XYZ,ABC); } Output
}; Int main() 20
Class ABC {
{ int a; ABC h;
Public: h.setvalue(10);
Void setvalue(int i) {a=i;} XYZ j;
Friend void max(XYZ,ABC); j.setvalue(20);
}; Max(h,j)
}
3/12/2020 Santosh A. Darade, SITS, Narhe 114
Pointers to Objects
student st; 51, Rajesh
student *ptr; void read_data( )
ptr = & st; void print_data( )
st
ptr 2FCD54
3/12/2020 Santosh A. Darade, SITS, Narhe 115
Pointers to Objects
• Pointers can be defined to hold the address of an
object, which is created statically or dynamically
Statically created object:
33, Joseph
student *stp;
stp = &st;
void read_data( )
Dynamically created object:
void print_data( )
student *stp;
stp = new student;
st
3/12/2020
2FCDA4 Santosh A. Darade, SITS, Narhe 116
Pointers to Objects
• Accessing Members of objects:
Syntax:
ptr_ob j member_name;
ptr_obj memberfunction_name( );
Example:
stp st_name;
stp read_data ( );
3/12/2020 Santosh A. Darade, SITS, Narhe 117
The this Pointer
• The this pointer points to the object that
invoked the function
• When a member function is called with an
object, it is automatically passed an implicit
argument that is a pointer to the invoking
object (that is, the object on which the
function is called).
3/12/2020 Santosh A. Darade, SITS, Narhe 118
The this Pointer
• Accessing Members of objects:
Syntax:
obj . memberfunction_name( );
this pointer points to st object
Example:
st . read_data ( );
3/12/2020 Santosh A. Darade, SITS, Narhe 119
Pointer to Class Member
• A special type of pointer that "points“
generically to a member of a class, not to a
specific instance of that member in an object
• Pointer to a class member is also called
pointer-to-member.
3/12/2020 Santosh A. Darade, SITS, Narhe 120
Pointer to Class Member
• It provides only an offset into an object of the
member's class at which that member can be
found.
• Member pointers are not true pointers, the . and
-> cannot be applied to them.
• A pointer to a member is not the same as a
normal C++ pointer.
3/12/2020 Santosh A. Darade, SITS, Narhe 121
Pointer to Class Member
• To access a member of a class:
Special pointer-to-member operators
1) .*
2) –>*
3/12/2020 Santosh A. Darade, SITS, Narhe 122
Pointer to Class Member
• Syntax to create pointer to data member
of a class:
Data_type class_name ::* data_member_ptr;
int student::*d_ptr;
• Syntax to create pointer to member function
of a class:
rtn_dt (class_name::* mem_func_ptr)(arguments);
int (student::*f_ptr)();
3/12/2020 Santosh A. Darade, SITS, Narhe 123
Thank you
3/12/2020 Santosh A. Darade, SITS, Narhe 124
Post a Comment