Friend class and function in C++
Friend Class A friend class can access private and protected members of other class in which it is declared as friend. It is sometimes useful to allow a particular class to access private members of other class. For example, a LinkedList class may be allowed to access private members of Node.
A friend class can access both private and protected members of the class in which it has been declared as friend.
CPP
class Node { private : int key; Node* next; /* Other members of Node Class */ // Now class LinkedList can // access private members of Node friend class LinkedList; }; |
C++
// Example: #include<iostream> using namespace std; class A { int x; public : A() { x=10; } friend class B; //friend class }; class B { public : void display(A &t) { cout<<endl<< "The value of x=" <<t.x; } }; main() { A _a; B _b; _b.display(_a); return 0; } |
The value of x=10
In this example, class B is declared as a friend inside the class A. Therefore, B is a friend of class A. Class B can access the private members of class A.
Friend Function Like friend class, a friend function can be given a special grant to access private and protected members. A friend function can be:
a) A member of another class
b) A global function
- A friend function is a special function in C++ which in-spite of not being member function of a class has privilege to access private and protected data of a class.
- A friend function is a non member function or ordinary function of a class, which is declared as a friend using the keyword “friend” inside the class. By declaring a function as a friend, all the access permissions are given to the function.
- The keyword “friend” is placed only in the function declaration of the friend function and not in the function definition.
- When friend function is called neither name of object nor dot operator is used. However it may accept the object as argument whose value it want to access.
- Friend function can be declared in any section of the class i.e. public or private or protected.
Syntax:-
Syntax : class <class_name> { friend <return_type> <function_name>(argument/s); };
C++
// Example: Find the largest of two numbers using Friend Function #include<iostream> using namespace std; class Largest { int a,b,m; public : void set_data(); friend void find_max(Largest); }; void Largest::set_data() { cout<< "Enter the First No:" ; cin>>a; cout<< "Enter the Second No:" ; cin>>b; } void find_max(Largest t) { if (t.a>t.b) t.m=t.a; else t.m=t.b; cout<< "Maximum Number is\t" <<t.m; } main() { Largest l; l.set_data(); find_max(l); return 0; } |
Enter the First No:Enter the Second No:Maximum Number is 0
Output:-
Enter the First No: 21 Enter the Second No:32 Maximum Number is 32
Friend Function to more than one classes / A Function Friendly to two classes:-
C++
// Prog: Demonstrates how friend functions work as a bridge between the classes #include<iostream> using namespace std; class ABC; // forward declaration class XYZ { int x; public : void set_data( int a) { x=a; } friend void max(XYZ,ABC); }; class ABC { int y; public : void set_data( int a) { y=a; } friend void max(XYZ,ABC); }; void max(XYZ t1,ABC t2) { if (t1.x>t2.y) cout<<t1.x; else cout<<t2.y; } main() { ABC _abc; XYZ _xyz; _xyz.set_data(20); _abc.set_data(35); max(_xyz,_abc); //callin friend function return 0; } |
35
CPP
class Node { private : int key; Node* next; /* Other members of Node Class */ friend int LinkedList::search(); // Only search() of linkedList // can access internal members }; |
Following are some important points about friend functions and classes:
1) Friends should be used only for limited purpose. too many functions or external classes are declared as friends of a class with protected or private data, it lessens the value of encapsulation of separate classes in object-oriented programming.
2) Friendship is not mutual. If class A is a friend of B, then B doesn’t become a friend of A automatically.
3) Friendship is not inherited (See this for more details)
4) The concept of friends is not there in Java.
A simple and complete C++ program to demonstrate friend Class
CPP
#include <iostream> class A { private : int a; public : A() { a = 0; } friend class B; // Friend Class }; class B { private : int b; public : void showA(A& x) { // Since B is friend of A, it can access // private members of A std::cout << "A::a=" << x.a; } }; int main() { A a; B b; b.showA(a); return 0; } |
A::a=0
A simple and complete C++ program to demonstrate friend function of another class
CPP
#include <iostream> class B; class A { public : void showB(B&); }; class B { private : int b; public : B() { b = 0; } friend void A::showB(B& x); // Friend function }; void A::showB(B& x) { // Since showB() is friend of B, it can // access private members of B std::cout << "B::b = " << x.b; } int main() { A a; B x; a.showB(x); return 0; } |
B::b = 0
A simple and complete C++ program to demonstrate global friend
CPP
#include <iostream> class A { int a; public : A() { a = 0; } // global friend function friend void showA(A&); }; void showA(A& x) { // Since showA() is a friend, it can access // private members of A std::cout << "A::a=" << x.a; } int main() { A a; showA(a); return 0; } |
A::a=0
Merits:-
- A friend function is able to access members without the need of inheriting the class.
- Friend function acts as a bridge between two classes by accessing their private data.
- It can be used to increase the versatility of overloaded operator.
- It can be declared either in the public or private or protected part of class.
Demerits:-
- Friend functions have access to private members of a class from outside the class which violates the law of the data hiding.
- Friend functions cannot do any run time polymorphism in its members.
References:
http://en.wikipedia.org/wiki/Friend_class
http://en.wikipedia.org/wiki/Friend_function
http://www.cprogramming.com/tutorial/friends.html
http://www.parashift.com/c++-faq/friends-and-encap.html
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.