Introduction
In C++, a class is a user-defined type or data structure that includes data and functions as members and whose access is controlled by the three access specifiers private, protected, and public. Access to members of a C++ class is usually restricted.
A function is a code block that only executes when it is invoked. Parameters are data that may be sent into a function. Functions are used to accomplish specific tasks and are essential for code reuse: Once you've defined the code, you may use it repeatedly.
Also see, Literals in C.Fibonacci Series in C++
What is the Friend Function in C++?
When a function is defined as a buddy function in C++, it has access to the protected and private data of the class. The term friend specifies that the specified function is a friend function to the compiler. For accessing data, a friend function should be declared inside the body of a class, beginning with the term friend.
In the declaration above, the word friend is used to prefix the friend function. The function can be declared anywhere in the program, just like any other C++ function. Neither the keyword friend nor the scope resolution operator in the function declaration is utilized.
Characteristics of Friend Function
-
The friend function does not belong to the class of which it is a friend.
-
It can't be called with the object since it's not in the scope of that class.
-
It may be invoked just like any other function without the object.
-
It is unable to obtain member names directly. As a result, it must utilize the dot membership operator with the member name and an object name.
- It might be written in a private or public area.
Ways to Implement a Friend Function in C++
There are different ways to implement the friend function in C++.
-
Inside the class
- Outside the class
1. Implementing the friend function Inside the class in C++
While implementing the friend function, you can define it in the class file as well. Below is an example for better understanding.
- C++ Code
C++ Code
#include <iostream>
using namespace std;
class Myclass {
private:
int value;
public:
Myclass(int data): value(data) {}
friend void display(Myclass& obj){
int value = obj.value;
cout<<"value of private data member: "<<value;
}
};
int main() {
Myclass myObj(98);
display(myObj);
return 0;
}
Output
2. Implementing the friend function Outside the class in C++
While implementing the friend function, you can define it outside the class file as well. Below is an example for better understanding.
- C++ Code
C++ Code
#include <iostream>
using namespace std;
class Myclass {
private:
int value;
public:
Myclass(int data): value(data) {}
friend void display(Myclass& obj);
};
void display(Myclass& obj){
int value = obj.value;
cout<<"value of private data member: "<<value;
}
int main() {
Myclass myObj(76);
display(myObj);
return 0;
}Output
Program 1:
- C++ Code
C++ Code
#include <iostream>
using namespace std;
class table
{
private:
int length;
public:
table(): length(0) { }
friend int printLength(table); //friend function
};
int printLength(table b)
{
b.length += 20;
return b.length;
}
int main()
{
table x;
cout<<"Length of table: "<< printLength(x)<<endl;
return 0;
}
Output:
Try and compile with online c++ compiler.
Example of Friend Function in C++
- C++ Code
C++ Code
#include <iostream>
using namespace std;
class two; // forward declarartion.
class one
{
int x;
public:
void setdata(int i)
{
x=i;
}
friend void min(one,two); // friend function.
};
class two
{
int y;
public:
void setdata(int i)
{
y=i;
}
friend void min(one,two); // friend function
};
void min(one a, two b)
{
if(a.x<=b.y)
std::cout << a.x << std::endl;
else
std::cout << b.y << std::endl;
}
int main()
{
one a;
two b;
a.setdata(5);
b.setdata(10);
min(a,b);
return 0;
}
Output
Features of Friend Functions in C++
- Allow access to private and protected members of a class
- Not members of a class but declared within its scope
- Can be declared within a class or outside it
- Can be declared as friend functions of multiple classes
- Cannot access the members directly using the dot operator
C++ Function Overloading Using Friend Function
Function overloading in C++ allows multiple functions with the same name but different parameter lists. Friend functions can be overloaded to work with different classes, providing flexibility in accessing private members.
- C++
C++
#include<iostream>
using namespace std;
class A {
int x;
public:
A() : x(0) {}
friend void display(A obj);
};
class B {
int y;
public:
B() : y(10) {}
friend void display(B obj);
};
void display(A obj) {
cout << "Value of x: " << obj.x << endl;
}
void display(B obj) {
cout << "Value of y: " << obj.y << endl;
}
int main() {
A a;
B b;
display(a);
display(b);
return 0;
}
Output:
Value of x: 0
Value of y: 10
Advantages of Friend Functions:
- Allows access to private and protected members of a class
- Can be used to implement operators for user-defined types
- Enhances encapsulation by restricting access to selected functions or classes
- Enables efficient code reuse by allowing non-member functions to operate on class objects
Disadvantages of Friend Functions:
- Breaks encapsulation by exposing private members to external functions
- Can make the code less readable and harder to maintain
- Increases coupling between classes, reducing flexibility and scalability
- Requires careful management to ensure proper access control and minimize security risks
26+ registered 
