Friend Function In C++ Classes | Types, Uses & More (+Examples)

A friend function in C++ is a unique kind of function that has access to a class's private and protected members. They are defined outside the class but can be identified as friends within the class, in contrast to member functions, which are a part of the class and have direct access to its private members.

In this article, we will discuss everything about the friend function in C++ programming language, ranging from how to declare them, their characteristics, global friend functions, overloading using friend functions, and much more with the help of examples.

What Is Friend Function In C++?

It is a special type of function in C++ programming that is declared in a class but can be defined outside the class. However, it always has access to all private and protected members of a class. This allows the friend function to operate private and protected data outside the class.

• We must use the friend keyword to declare a friend function in C++ classes. 
• A friend can be a member's function, function template, normal function, or class or class template, in which case the entire class and all of its members are friends.
• Understanding friend functions in C++ comes in handy when you need to give external functions access to a class's private members without making those members public.
• However, as they could weaken encapsulation and potentially make code more difficult to maintain, friend functionality should only be used selectively.

When communicating with a class's private members, it's generally preferable to use the public member functions.

Declaration Of Friend Function In C++ With Example

As mentioned before, a C++ friend function is declared by using the friend keyword. It can be declared anywhere in the class, i.e., private, protected, or public. The syntax for the same is given below, followed by an example C++ program.

Syntax Of Friend Function In C++:

class class_name {
access_specifier:
friend return_type function_name(arguments);
};

Here,

• The name/ identifier of the class is given by class_name, and the name of the friend function is given by function_name.
• The visibility mode of the function is given by access_specifier, which can be private, public or protected.
• The keyword friend signifies that the function is being declared as a friend function, which takes parameters represented by arguments.
• And return_type reflects the data type of the function's return value.

Now, let look at the implementation of the concept of friend function in C++ program given below.

Code Example:

#include <iostream>
using namespace std;

class MyClass {
private:
int privateData;

public:
MyClass(int data): privateData(data) {}
friend void friendFunction(MyClass obj);
};

// Definition of the friend function
void friendFunction(MyClass obj) {
cout << "The friend function can access privateData: " << obj.privateData << endl;}

int main() {

MyClass obj(42);
friendFunction(obj);
return 0;
}

Output:

The friend function can access privateData: 42

Explanation:

In the simple C++ program-

1. We begin by including the <iostream> header to use the cout and cin commands and also use the namespace std.
2. Then, we create a class called MyClass which has a private data member named privateData and a constructor to initialize it.
3. We also declare a friendFunction a friend, which takes the MyClass object as an argument.
4. As mentioned in code comments, we define the friendFunction outside the class. It will print the value of a private data member by using the object of MyClass and a cout statement.
5. Next, in the main() function, an object of MyClass, obj, with the initial value 42, is created.
6. Then obj is passed as a parameter when calling the friendFunction. The object's private member privateData is accessed inside the friendFunction and printed to the console using cout.

Note: It is evident from the example above that despite not being a member of the class itself, the friend function has access to the private member privateData of the MyClass object.

Characteristics Of Friend Function In C++

The friend function has many important characteristics that make it an integral part of C++ programming. Some important features of the friend function in C++ are as follows:

• Although friend functions are not class members, they have access to private and protected class members. 
• A friend function in C++ program can be overloaded. You can declare multiple friends functions with the same name but different parameter lists.
• Friend functions are declared within the class using the friend keyword. They do not have a storage class specifier.
• They can be used to access and manipulate private data of the class without violating encapsulation.
• Friend functions in C++ can be defined inside or outside the class declaration.
• They can be regular functions or member functions of other classes declared as friends.
• Friend functions are not members of the class and do not have direct access to the class's 'this' pointer.
• A friend function in C++ cannot directly access the protected or private data members of the class. It has to make use of an object (instance of that class) either through the dot membership operator (.) or by passing a class object as an argument.
• Multiple functions or classes can be declared as friends of a single class.
• Derived classes do not inherit friend functions.
• Friendship is not mutual. That is, if class A is a friend of class B, it does not imply that class B is a friend of class A.
• The concept of friend function in C++ is typically used to provide external class member functions or classes with special access to private or protected members of a class.

Way To Implementat Friend Function In C++

A friend function in C++ can be implemented in two ways:

1. As a global function
2. As the member function of another class

We will discuss both of these in greater detail in the sections ahead.

Global Friend Function In C++ (Global Function As Friend Function )

The functions that are declared outside of a class or namespace and are accessible from any place in the program are known as global functions.

• The main() function can invoke these global friend functions in C++ without requiring an object.
• A global function can be attached as a friend function to one or more classes.
• Once attached, the global function has direct access to the class's private and protected members.

The syntax for the declaration of a global friend function in C++ is given below, along with an example of its implementation. 

Syntax Of Global Friend Function In C++:

class class_name{
access_specifier:
friend return_type global_function(arguments);
};
return_type global_function(arguments) {
}

Here,

• The terms class_name and global_function refer to the names of the class that contains the friend function and the name of the global friend function, respectively.
• The access_specifier refers to the access controller, i.e., public, private, or protected.
• The keyword friend indicates that this is a friend function.
• arguments refer to the parameters that the friend function will take, and return_type reflects the data type of the value returned by the global_function.

Let’s understand the concept of the global friend function in C++ program with an example.

Code Example:

#include <iostream>
using namespace std;

class MyClass {
private:
int data;

public:
MyClass(int value) {
this->data=value;}

void displayData() {//function that displays the data
cout << "Data: " << data << endl;}

// Declare friend function using friend keyword
friend void multiplyByTwo(MyClass& obj);
};

// global function, which multiplies the number by two
void multiplyByTwo(MyClass& obj) {
obj.data *= 2; // it is accessing the private data of MyClass
}

int main() {
MyClass obj(5);
obj.displayData(); // Output: Data: 5
multiplyByTwo(obj);
obj.displayData(); // Output: Data: 10

return 0;
}

Output:

Data: 5
Data: 10

Explanation:

We begin the example C++ code by including essential headers and the namespace.

1. Then, we create a class named MyClass with a private integer member, data, and a constructor to initialize it.
2. The class includes a member function called displayData() to output the value of data using cout.
3. Next, we declare is a friend function multiplyByTwo() declared inside the class, allowing it to access the private data member.
4. Note that multiplyByTwo() is a global function and is a friend to MyClass.
5. It uses the compound assignment operator (*=) to double the value of data for a given MyClass object, as given in the definition outside the class.
6. In the main() function, a MyClass object obj is created with an initial value of 5.
7. Then, we call multiplyByTwo(obj) function to double the value of data variable, and the updated value is displayed using displayData().
8. As shown in the output, the friend function can access the data variable and returns the required value.
9. Finally, the program terminates with a return 0 statement, indicating no errors in execution.

Note that the friend function doesn’t have access to this pointer. So, it has to use the object of a class to access the private data members.

Member Function Of Another Class As Friend Function In C++

In C++, a member function of one class may be designated as a friend function in another class. As a result, the class in which the friend function is declared has access to both its protected and private data members. Such a class can also referred to as the C++ friend class. Here is the class definition: 

Syntax:

classclass_B; //Forward declaration of the class
class class_A {
public:
return_type friendFunction(arguments); //Declaring the friend function
};

class class_B {
access_specifier:
friend return_type class_A::friendFunction(arguments);
};

return_type class_A::friendFunction(arguments) {
}

Here, 

• class_A refers to the names of the class that contains a class function that is a friend to class_B.
• class_B is the name of the class that declares the member function of class_A as a friend to it.
• access_specifier is an access controller, which could be public, private, or protected.
• The keyword friend signifies that the function is a friend function, and friendFunction refers to its name.
• The arguments are parameters that the friendFunction will take, and retun_type refers to the data type of the function's return value. 

Code Example:

#include <iostream>
using namespace std;

class MyClass; // Forward declaration

class FriendClass {
public:
void friendFunction(MyClass obj); // Declaration of friend function
};

class MyClass {
private:
int privateData;
public:
MyClass(int data): privateData(data) {}
friend void FriendClass::friendFunction(MyClass obj); // Declaration of friend function from FriendClass
};

void FriendClass::friendFunction(MyClass obj) {
cout << "The friend function of FriendClass can access privateData: " << obj.privateData <<endl;}

int main() {
MyClass obj(42);
FriendClass fc;
fc.friendFunction(obj); // Output: Friend function of FriendClass can access privateData: 42
return 0;
}

Output:

The friend function of FriendClass can access privateData: 42

Explanation:

In the C++ example code-

1. We first declared two classes MyClass and FriendClass.
2. The FriendClass has a member function declaration named friendFunction, which will later be declared as a friend function in MyClass.
3. The MyClass has a private member privateData, a constructor to initialize it, and a friend declaration, i.e., FriendClass::friendFunction.
4. Note that the friendFunction is a member function of a FriendClass and a friend function to MyClass.
5. The friend function is defined outside of a class using a scope resolution operator (::). The function prints the value of the privateData member of a MyClass object which is passed as an argument using cout.
6. In the main() function, an object of MyClass named obj is created with an initial value of 42.
7. Following this, we create an object of FriendClass named fc without any initial value.
8. Next, we call friendFunction on the FriendClass object fc, passing the MyClass object obj as an argument.
9. The friend function accesses and prints the private member privateData of MyClass.

Function Overloading Using Friend Function In C++

Function Overloading helps to achieve compile time polymorphism. One can declare multiple functions with the same name but different function prototypes inside a class and then make them friends by using function overloading with friend function in C++.

• These friend functions may be implemented outside of the class and may have various parameter lists.
• They can access the class's private and protected members by identifying them as friends, which enables them to behave differently depending on the function's parameters.

The use of the friend function in C++ to overload functions is an effective technique for offering several customized operations on the private data of the class. Look at overloading with friend function in C++ example below to gain a better understanding of this concept.

Code Example:

#include <bits/stdc++.h>
using namespace std;

class Bank {
private:
string account_holder;
int account_number;
int balance;

public:
Bank(int balance,string name,int account_number){
this->balance=balance;
account_holder=name;
this->account_number=account_number;}

//First overloaded execute function, which takes a reference to the bank object
friend void execute(Bank obj);

// second overloaded function, which takes two parameters and prints the account holder’s name
friend void execute(int account_num,Bank obj);
};

//defining the first overloaded function
void execute(Bank b) {
cout << "The balance in the bank is: " << b.balance << endl;
}

//defining the second overloaded function
void execute(int account_num,Bank obj) {
cout << "The account holder's name for the given account num is: " << obj.account_holder<<endl;}

int main() {
Bank b(42,"Sekhar",23561423);

execute(b);
int account_num =23561423;
execute(account_num,b);
return 0;
}

Output:

The balance in the bank is: 42
The account holder's name for the given account num is: Sekhar

Explanation:

We begin by including <bits/stdc++.h> header file and use the namespace std.

1. Then, we create a class named Bank with three private data members, i.e., balance, account_number, and account_holder (string data type).
2. The class also has a constructor to initialize the data members using 'this' pointer, i.e., Bank().
3. Next, we define two friend functions with the same name, i.e., execute. This leads to function overloading since both have the same name but different prototypes. They are defined outside the class.
4. The first execute function accepts a Bank obj (object) as an argument and prints the value using cout.
5. The second execute function accepts an integer and Bank obj (object) and prints value using cout.
6. Next, in the main() function, we create an object of Bank class named b and also define an integer variable account_num.
7. Then, we call execute function twice, once with the obj object and once with the num variable along the Bank class object.
8. The first execute function is a friend of the Bank class and can access the private data member balance, which is printed to the console.
9. The second execute function accepts two parameters and prints the account holder's name.

Here, both execute functions have the same name but different prototypes, so the compiler decides which execute the function to be called based on the parameter types at compile type.

Advantages & Disadvantages Of Friend Function in C++

Listed in the table below are some of the major advantages and disadvantages of a friend function in C++.

What Is A C++ Friend Class?

A friend class in C++ is similar to a friend function with special access privileges to another class. A class can identify another class as a friend to have access to the secret and protected members of that class. This promotes flexibility and cooperation across classes by allowing friend class to communicate with and alter the internal data of the other class. It is a way for classes to connect closely by building a relationship of friendship in which one class grants another class special access to its secrets.

Syntax Of C++ Friend Class

class class_name {
access_modifier:
friend class friend_class_name;
}

Here,

• class_name is the name of the class in which the friend class is declared
• access_modifier is an access controller which could be public, private, or protected.
• friend is the keyword used to declare a friend class.
• friend_class_name is the name of the class which is declared as a friend to class_name.

Code Example:

#include <iostream>
using namespace std;

class beta; // friend class

class alpha { // Class that builds a friendship with beta class
private:
int data;
public:
alpha(int data) {
this->data=data;}

friend class beta;
};

class beta {
public:
void display(const alpha& obj) {
cout<< "Private data of alpha class accessed by beta class: " << obj.data << endl;}
};

int main() {
alpha obj(42);
beta friend_Obj;
friend_Obj.display(obj);
return 0;
}

Output:

Private data of alpha class accessed by beta class: 42

Explanation:

In the example C++ program-

1. We create the two classes named alpha and beta. The alpha class will give access to the friend class. Beta is the friend class that will have access to alpha's private members.
2. The alpha class has a private member variable called data and a constructor to initialize it.
3. Inside the alpha class, we have declared beta as a friend of alpha using the friend keyword. This grants beta access to the private members of alpha.
4. In the beta class, we define a member function called display. This function takes a reference to an alpha object as a parameter and uses this object to access the private data member of the alpha class.
5. The display function prints the private data member using the cout command. 
6. In the main function, we create an object of class alpha named obj and initialize it with a value of 42.
7. Then we create an object of beta called friendObj.
8. Next, we call the display function using friendObj and pass obj, the alpha class object, as an argument.

Note that display() is a member function of the beta class, which is a friend to the alpha class. It can hence access the private data member of alpha and print to the console.

A Function Friendly To Multiple Classes

In C++, a function can be declared as a friend to multiple classes. This makes it possible for the function to access the protected and private members of various classes. This will be useful when we need the classes to be collaborative and require strong communication between them. Let’s consider an example to better understand this concept.

Code Example:

#include <iostream>
using namespace std;


class ClassA; // Forward declaration
class ClassB; // Forward declaration

class FriendFunction {
public:
void doSomething(ClassA objA, ClassB objB); // Declaration of the friend function
};

class ClassA {
private:
int privateDataA;
public:
ClassA(int data): privateDataA(data) {}
friend void FriendFunction::doSomething(ClassA objA, ClassB objB);
// Declaration of friend function from FriendFunction
};

class ClassB {
private:
int privateDataB;
public:
ClassB(int data): privateDataB(data) {}
friend void FriendFunction::doSomething(ClassA objA, ClassB objB);
// Declaration of friend function from FriendFunction
};

void FriendFunction::doSomething(ClassA objA, ClassB objB) {
cout<< "Friend function can access privateDataA: " << objA.privateDataA << endl;
cout<< "Friend function can access privateDataB: " << objB.privateDataB << endl;}

int main() {

ClassA objA(42);
ClassB objB(24);
FriendFunction ff;
ff.doSomething(objA, objB); // Friend function can access privateDataB: 24
return 0;
}

Output:

Friend function can access privateDataA: 42
Friend function can access privateDataB: 24

Explanation:

In the example-

1. We forward declare two classes, i.e., classA and classB, and then define a friend class called FriendFunction,
2. The FriendFunction class has a member function declaration named doSomething, which will later be declared as a friend function in ClassA and ClassB. 
3. The ClassA has a private member named privateDataA and a constructor to initialize it.
4. Similarly, ClassB has a private member named privateDataB and a constructor to initialize it.
5. We have also declared a friend function, i.e., FriendFunction::doSomething, in both classes.
6. Next, we define the doSomething friend function outside of the class using the scope resolution operator. It accepts objects of ClassA and ClassB as arguments.
7. Inside the function, it accesses the private members privateDataA and privateDataB using corresponding objects. And prints the values of the members using the cout command.
8. In the main() function, we create an object for both the classes, that for ClassA, objA and for ClassB, objB.  We also initialize them with the values of 42 and 24, respectively.
9. Next, we create an object of FriendFunction called ff.
10. We then call the doSomething function using ff, and the objects of classA and classB are passed to it. 
11. The output is hence printed on the console, and the program finishes execution with a return 0.

C++ Friend Class Vs. Friend Function In C++

We have discussed the concepts of friend class and friend function in C++, in the sections above. Now let's take a look at the below, which highlights the differences between the two.

Some Important Points About Friend Functions And Classes In C++

Here are some points that you must keep in mind when working with friend classes and friend functions in C++. 

• Access to Private and Protected Members: Friend classes and functions have access to a class's private and protected members, including its protected members, private variables, and private methods. This enables more adaptable and effective code because some activities could need direct access to the members of the secret or protected data.
• Non-Inheritance Relationship: The use of friend classes and functions does not indicate that there is an inheritance link. They offer a way to access secret or protected members for particular functions or classes without the need for inheritance.
• Encapsulation and Information Hiding: Since friend functions and friend classes have direct access to a class's internal implementation details, they often break encapsulation and information-hiding rules. As a result, it's crucial to only use friend methods and friend classes when absolutely essential.
• Friendship is Not Mutual: By nature, friendship is not mutual. Class B is not necessarily a friend of class A just because class A is a friend of class B. If mutual access is wanted, friendship must be explicitly stated for both classes.
• Friendship is Not Inherited: If a derived class inherits from a base class, then the friend function of the base class doesn’t have access to the private data of the derived class. So, the friend function is not inherited in the derived class.

Conclusion

A friend function in C++ is a special function that is not a member of a class but has access to its protected and private members. They are often defined outside of the class but are declared inside of it using the friend keyword.

• They come in handy when you need to give particular functions or external classes access to a class's secret data without making those members publicly available.
• Since friend functions are not inherited, derived classes cannot use them.
• Friend functions in C++ are not connected to any instances of the class, and they lack this pointer.
• They are frequently used to overload operators so that non-member functions can interact with members of private classes.
• Although friend functions can increase flexibility and convenience in some situations. However, it is typically advised to use them rarely and to give priority to encapsulation.
• A friend class scope grants access to another class or multiple classes to manage its own private and protected members. This is done using a friend keyword.
• Friend classes offer a way of establishing strong relationships between classes and permit a more flexible and managed exchange of data and functionality.
• Friendship, i.e., friend relations, cannot be inherited, and it is non-commutative.

Frequently Asked Questions

Q. What is a friend function in C++ with example?

A friend function is a special type of function that is declared in a class as a friend and defined outside the class. It can access private and protected members of a class just like other member functions. Let’s understand with an example.

Code Example:

#include <iostream>
using namespace std;

class Circle {
private:
double radius;
public:
Circle(double r) : radius(r) {}
friend double calculateArea(const Circle& c);
};

// The friend function calculates the area of a Circle
double calculateArea(const Circle& c) {
double area = 3.14 * c.radius * c.radius;
return area;}

int main() {
Circle myCircle(5.0);
double area = calculateArea(myCircle);
cout << "Area of the circle: " << area << endl;
return 0;
}

Output:

Area of the circle: 78.5

Explanation:

1. In this example, we created a Circle class with a private member variable named radius and a constructor to initialize it.
2. Within the Circle class, the calculateArea function is listed as a friend function. This implies that it has access to the Circle objects' private member variables.
3. The formula 3.14 * radius * radius is used by the calculateArea function to determine the area of a circle depending on its radius when it receives a constant reference to a Circle object as an argument.
4. In the main function, we created the Circle class object myCircle, with a radius of 5.0.
5. We then call the calculateArea function with the myCircle object. Since calculateArea is a friend function, it can access the private radius member of myCircle to perform the calculation.

Q. Is the friend function in C++ the same as the inheritance?

No, in C++, friend functions and inheritance are two different concepts. Friend functions (or classes) provide other functions (or other classes) access to its class's private and protected members.

• The class declares these functions as friends, granting them access to the private members while not being class members.
• The class hierarchy and inheritance do not apply to individual friend functions.

On the other hand, in object-oriented programming, inheritance is a method that enables a class (derived class) to inherit the characteristics and actions of another class (base class).

• Since the derived class inherits the base class's members (variables and functions), inheritance creates an Is-A relationship between classes.
• A class hierarchy is produced by inheritance, with derived classes inheriting and expanding the capabilities of the base class.

Q. What is the syntax of a friend class

The syntax to create a C++ friend class is given below, along with an explanation of its components. 

Syntax:

class class_name {
access_modifier:
friend class friend_class_name;
}

Here,

• class_name: It is the name of the class in which the friend class is declared
• access_modifier: It is an access controller which could be a public, private, protected
• friend: It is the keyword used to declare a friend class
• friend_class_name: It is the name of the class which is declared as a friend to its class_name class.

Q. Is the friend function in C++ helpful in function overloading?

Yes, function overloading is a fundamental concept of writing multiple functions with the same name but different prototypes. A friend function in C++ helps to achieve function overloading by having multiple functions with customized behavior. Function overloading is often known as compile-time polymorphism. let’s see an example to understand the same.

Code Example:

#include <iostream>
using namespace std;

class MyClass {
private:
int data;
public:
MyClass(int d): data(d) {}

// Friend function declarations
friend void display(const MyClass& obj);
friend void display(const MyClass& obj, int value);
};

// Friend function definition for display
void display(const MyClass& obj) {
cout << "Data: " << obj.data << endl;}

// Overloaded friend function definition for display
void display(const MyClass& obj, int value) {
cout << "Data + Value: " << obj.data + value << endl;}

int main() {
MyClass myObj(42);
display(myObj); // Calls the first friend function
display(myObj, 10); // Calls the second overloaded friend function
return 0;
}

Output:

Data: 42
Data + Value: 52

Explanation:

In this example, a class called MyClass is created with a private data variable named data. The class also declares two friend functions with the same name display.

• The first display friend function takes a constant reference to a MyClass object as a parameter. It accesses the private member data of the MyClass object and prints its value to the console.
• The second display friend function is an overloaded function of the first display method. It takes a constant reference to a MyClass object and an additional integer value as parameters. It accesses the private member data of the MyClass object and adds the provided integer value to it.
• In the main function, an instance of the MyClass class named myObj is created with a value of 42.
• We then call the first friend function display with myObj as a parameter. It accesses and prints the value of the private member data using cout.
• Finally, we call the second friend function display with myObj and the value 10 as arguments. It accesses the private member data and adds 10 to it.

Q What is the difference between the friend function and an inline function in C++?

Some of the primary differences between the friend function in C++ and an inline function are as follows:

Note:

When an inline function is invoked, the entire inline function's code is added or replaced at the inline function call position. The C++ compiler makes this substitution at the time of compilation.

Q. What is the need for the friend function in C++?

Friend functions play an important role in C++ programming. Listed below are some of the primary reasons why we need them.

• Accessing private members: Friend functions give certain external functions or classes controlled access to a class's private and protected members so they can work on them.
• Simplifying implementation: Friend functions can make the implementation of complicated actions involving numerous classes simpler by directly accessing and interacting with their private members.
• Operator overloading: To enable the implementation of customized behaviour for operators like +, -, *, etc., outside the class. A friend function in C++ is frequently used in operator overloading to allow access to private members.

Quiz Time!!!

You might also be interested in reading the following:

1. C++ Type Conversion & Type Casting Demystified (With Examples)
2. Destructor In C++ | Understanding The Key To Cleanups (+ Examples)
3. C++ Exception Handling | Use Try, Catch, & Throw (+Examples)
4. Constructor Overloading In C++ Explained With Real Examples
5. Typedef In C++ | Syntax, Application & How To Use It (With Examples)