Lecture-11 Friend Functions and inline functions.pptx

Object Oriented Programming
Lecture # 11
Dr. Shafiq Hussain
Associate Professor & Chairperson
Department of Computer Science
1

Learning Objective
• To demonstrate the concept of Friend Functions in OOP.
• To demonstrate the concept of Inline Functions in OOP.
• To demonstrate This Pointer in OOP.
• To demonstrate the Static Members in OOP.
2

Friend Functions
• A friend function of a class is defined outside that class' scope
but it has the right to access all private and protected members
of the class.
• Even though the prototypes for friend functions appear in the
class definition, friends are not member functions.
• A friend can be a function, function template, or member
function, or a class or class template, in which case the entire
class and all of its members are friends.

Friend Functions (Cont..)
To declare a function as a friend of a class, precede the function
prototype in the class definition with keyword friend as follows:
class Box
{
double width;
public:
double length;
friend void printWidth( Box box );
void setWidth( double wid );
};

To declare all member functions of class ClassTwo as friends of
class ClassOne, place a following declaration in the definition of
class ClassOne:
friend class ClassTwo;

#include <iostream>
#include <conio.h>
using namespace std;
class Box
{
double width;
public:
friend void printWidth( Box box );
void setWidth( double wid );
};

void Box::setWidth( double wid )
{
width = wid;
}
// Note: printWidth() is not a member function of any class.
void printWidth( Box box )
{
/* Because printWidth() is a friend of Box, it can directly access any
member of this class */
cout << "Width of box : " << box.width <<endl;
}

main( )
{
Box box;
// set box width without member function
box.setWidth(10.0);
// Use friend function to print the wdith.
printWidth( box );
getch();
}

When the above code is compiled and executed, it produces the
following result:
• Width of box : 10

Inline Functions
• C++ inline function is powerful concept that is commonly
used with classes.
• If a function is inline, the compiler places a copy of the code
of that function at each point where the function is called at
compile time.
• Any change to an inline function could require all clients of
the function to be recompiled because compiler would need to
replace all the code once again otherwise it will continue with
old functionality.

Inline Functions (Cont..)
• To inline a function, place the keyword inline before the
function name and define the function before any calls are
made to the function. The compiler can ignore the inline
qualifier in case defined function is more than a line.
• A function definition in a class definition is an inline function
definition, even without the use of the inline specifier.

#include <iostream>
#include <conio.h>
inline int Max(int x, int y)
{
return (x > y)? x : y;
}
main( )
{
cout << "Max (20,10): " << Max(20,10) << endl;
cout << "Max (0,200): " << Max(0,200) << endl;
cout << "Max (100,1010): " << Max(100,1010) << endl;
getch();
}

• Max (20,10): 20
• Max (0,200): 200
• Max (100,1010): 1010

This Pointer
• Every object in C++ has access to its own address through an
important pointer called this pointer.
• The this pointer is an implicit parameter to all member
functions.
• Therefore, inside a member function, this may be used to refer
to the invoking object.

This Pointer (Cont..)
• Friend functions do not have a this pointer, because friends are
not members of a class.
• Only member functions have a this pointer.
• The ‘this’ pointer is passed as a hidden argument to all non-
static member function calls and is available as a local variable
within the body of all nonstatic functions.

• The ‘this’ pointer is a constant pointer that holds the memory
address of the current object.
• The ‘this’ pointer is not available in static member functions as
static member functions can be called without any object (with
class name).
• ‘this’ pointer is used when local variable’s name is same as
member’s name

#include<iostream>
#include<conio.h>
class Test
{
private:
int x;
public:
void setX (int x)
{
this->x = x;
}
void print()
{ cout << "x = " << x << endl; }
};

main()
{
Test obj;
int x = 20;
obj.setX(x);
obj.print();
getch();
}

Static Members
• We can define class members static using static keyword.
• When we declare a member of a class as static it means no
matter how many objects of the class are created, there is only
one copy of the static member.
• A static member is shared by all objects of the class. All static
data is initialized to zero when the first object is created, if no
other initialization is present

Static Members (Cont..)
#include <iostream>
#include <conio.h>
class Box
{
public:
static int objectCount;
// Constructor definition

Box(double l=2.0, double b=2.0, double h=2.0)
{
cout <<"Constructor called." << endl;
length = l;
breadth = b;
height = h;
// Increase every time object is created
objectCount++;
}

double Volume()
{
return length * breadth * height;
}
private:
double length; // Length of a box
double breadth; // Breadth of a box
double height; // Height of a box
};
// Initialize static member of class Box
int Box::objectCount = 0;

main(void)
{
Box Box1(3.3, 1.2, 1.5); // Declare box1
// Print total number of objects.
cout << "Total objects: " << Box::objectCount << endl;
getch();
}

• By declaring a function member as static, you make it
independent of any particular object of the class.
• A static member function can be called even if no objects of
the class exist and the static functions are accessed using only
the class name and the scope resolution operator ::.
• A static member function can only access static data member,
other static member functions and any other functions from
outside the class.

#include <iostream>
#include <conio.h>
class Box
{
public:
static int objectCount;

double Volume()
{
return length * breadth * height;
}
static int getCount()
{
return objectCount;
}

private:
double length; // Length of a box
double breadth; // Breadth of a box
double height; // Height of a box
};
// Initialize static member of class Box
int Box::objectCount = 0;

main(void)
{
// Print total number of objects before creating object.
cout << "Inital Stage Count: " << Box::getCount() << endl;
// Print total number of objects after creating object.
cout << "Final Stage Count: " << Box::getCount() << endl;
getch();
}

Questions
Any Question Please?
You can contact me at: drshafiq@uosahiwal.edu.pk
Your Query will be answered within one working day.
30

Further Readings
• C++ How to Program by Dietel, Chapter 6 and 9.
31

Lecture-11 Friend Functions and inline functions.pptx

More Related Content

What's hot (20)

Similar to Lecture-11 Friend Functions and inline functions.pptx (20)

Recently uploaded (20)

Lecture-11 Friend Functions and inline functions.pptx