Friend Function in C++

Updated September 1, 2023

Introduction to Friend Function in C++

In C++, encapsulation is a key principle in object-oriented programming, aiming to restrict direct access to an object’s internal data. However, there are scenarios where external functions need access to private or protected members of a class. This is where friend functions come into play. A friend function is a unique concept in C++ that allows non-member functions to access private and protected members of a class. This article will delve into the features, syntax, and characteristics of friend functions, providing a clear understanding of their role in maintaining a balance between encapsulation and necessary access.

Table of Contents

• Introduction
• What is it?
• Syntax
• How does it Work?
• Implementation
• Merits
• Demerits
• Examples
• Characteristics
• Restrictions and Best Practices
• Common Mistakes
• Debugging Issues
• Alternative Approaches

What is the Friend Function in C++?

In C++, a friend function allows non-member functions to access private and protected members of a class. This provides a way to maintain encapsulation while allowing controlled external access to a class’s internals.

A friend function exists outside the class’s scope, unlike regular member functions, which belong to the class and directly access its private members. The friend keyword, used within the class declaration, designates a function as a friend, indicating that the function enjoys special access privileges.

Programmers commonly use friend functions in scenarios where a function must manipulate private members of a class without compromising encapsulation. This can include implementing operators, utility functions, or functions that require direct access to a class’s private data.

Developers can balance data protection and functional flexibility in their C++ programs by carefully choosing which functions to declare as friends.

Key Takeaways

• Friend functions allow non-member functions to access private and protected members of a class, promoting controlled data sharing without violating encapsulation.
• You can declare them outside the class but designate them as “friends” to specific classes, facilitating close collaboration while maintaining data security.
• Friend functions provide a strategic way to balance encapsulation and extensibility, enabling external functions to work effectively with class internals only where necessary.

Syntax

class <className>{
<few lines of code goes here>
private <variable>
protected <variable>
friend <returnDatatype> <functionName>(arguments list);
}
returnDatatype functionName(arguments list){
//function from which protected and private keywords
//can be accessed from as this is a friend method of className
}

Representation:

Explanation:

As demonstrated in the code above, you must declare the friend function within the same class where you have declared the protected or private keyword for those data to be accessible outside the class. You can declare this function anywhere in the entire program, similar to a normal C++ method. The function definition does not need keywords like “friends” or “scope resolution operators.”

How Friend Functions Work in C++?

In C++, friend functions link class encapsulation and external functions, enabling regulated access to a class’s private and protected members. They operate through the explicit declaration of specific non-member functions as “friends” of a class. These external functions now have access to the private and protected members of the class, thereby circumventing the typical access limitations.

Here’s how friend functions work step by step:

• Declaration: To add a function as a friend of a class, you must declare it inside the class using the “friend” keyword. This declaration tells the compiler that the provided function can access the class’s private members.
• Access Privileges: Once you designate an external function as a friend, it gains access to the private and protected members of the class instance. There is no need for workarounds or object-specific permissions for this access.
• Definition: Like a typical non-member function, you define the friend function outside the class. Then, even though it has access to private members like a class member, it can be invoked like any other function.
• Passing Parameters: To access the members of a class, a reference or pointer to an object in the class must be supplied to friend functions because they are not class members
• No Inheritance: Friendships do not pass down through inheritance. Derived classes won’t have access to the friend function by default, even if they originate from the original class.
• Scoping: Friend functions need to be in the scope where they are called. Therefore, they should be defined before usage.

Friend functions give class designers and participants more flexibility by providing a regulated means to disclose internal data to particular external functions. They are especially helpful when creating intricate links between classes or putting non-member functions in place that need access to personal information. Its use should be moderate to uphold the encapsulation principles and guarantee the readability and maintainability of your code.

Implementation of Friend Function in C++

Below are the different examples to implement friend function in C++:

1. Global Friend Function in C++

A friend function that is declared outside of any class is referred to as a global friend function. It has access to one or more classes’ private members.

Example:

#include <iostream>
class SubClass {
private:
int x;
public:
SubClass() : x(12) {}
// Declare the global friend function
friend void displayPrivateValue(SubClass obj);
};
// Define the global friend function
void displayPrivateValue(SubClass obj) {
std::cout << "The private value x is: " << obj.x << std::endl;
}
int main() {
SubClass myObject;
// Call the global friend function to access the private member
displayPrivateValue(myObject);
return 0;
}

Output:

2. Friend Function as a Method of Another Class

You can define a friend function as a method of a different class in addition to global friend functions. By doing so, a certain class is given access to the private members of another class.

Example:

#include <iostream>
class FriendClass;  // Forward declaration
class MyClass {
private:
int secretValue;
public:
MyClass(int value) : secretValue(value) {}
// Declare FriendClass as a friend class
friend class FriendClass;
};
class FriendClass {
public:
// Friend function that can access the private member of MyClass
void accessSecretValue(MyClass& obj) {
std::cout << "Accessing secret value from FriendClass: " << obj.secretValue << std::endl;
}
};
int main() {
MyClass myObj(42);
FriendClass friendObj;
friendObj.accessSecretValue(myObj);  // Friend function accessing private member
return 0;
}

Output:

Merits of Friend Function in C++

• Access to Private Members: You can conduct actions that require direct access to a class’s private and protected members by using friend functions, which can gain access to those members. Data encapsulation and implementation details may benefit from this.
• Non-Member Function: Friend functions do not fall under the class’s interface because they are not class members. This can keep the class interface tidy and concentrated on its main duties.
• Operator Overloading: Friend functions are frequently employed to overload operators for user-defined types. For instance, you could create a friend function to overload the or >> operator for unique input and output actions.
• Flexibility: Friend functions could be specified in multiple classes or even separate namespaces. This enables more flexibility while developing and putting into use complicated systems.

Demerits of Friend Function in C++

• Encapsulation Violation: Although friend functions can be useful, they also violate encapsulation because they provide external functions with direct access to private members. The integrity of the data for a class may be tougher to preserve as a result.
• Complexity:  In large projects where it may not be immediately obvious which methods can access a class’s private members, Friend functions can make the code more complex and difficult to understand.
• Security Risks: Giving private members access to external functions may present security concerns. If you don’t use friend functions correctly, they can lead to unintentional data tampering or improper use of class internals.
• Tight Coupling: External functions are defined as friends of a class benefit from tight coupling with it. This can make modifying the class’s implementation challenging without changing these external functions.
• Reduced Information Hiding: The main objective of encapsulation is to conceal a class’s internal workings. When utilized excessively, friend functions might lessen the efficiency of information hiding and make it more difficult to manage and alter the class later.

Examples of Friend Function in C++

Below are the examples to understand friend unction using C++:

Example #1 – Friend Function for a Class

Code:

#include<iostream>
class DemoClass {
private:
int privateData;
public:
DemoClass() : privateData(0) {}
// Declare a friend function
friend void friendFunction(DemoClass obj);
void setPrivateData(int data) {
privateData = data;
}
};
// Define the friend function
void friendFunction(DemoClass obj) {
std::cout << "Friend Function: Accessing private data from DemoClass: " << obj.privateData << std::endl;
}
int main() {
DemoClass obj;
obj.setPrivateData(22);
// Call the friend function
friendFunction(obj);
return 0;
}

Output:

Example #2 – Friend Function for Two Classes

Code:

#include <iostream>
class ClassB; // Forward declaration
class ClassA {
private:
int dataA;
public:
ClassA() : dataA(0) {}
void setDataA(int data) {
dataA = data;
}
// Declare a friend function for ClassB
friend void friendFunction(ClassA objA, ClassB objB);
};
class ClassB {
private:
int dataB;
public:
ClassB() : dataB(0) {}
void setDataB(int data) {
dataB = data;
}
// Declare a friend function for ClassA
friend void friendFunction(ClassA objA, ClassB objB);
};
// Define the friend function
void friendFunction(ClassA objA, ClassB objB) {
std::cout << "Friend Function: Accessing data from ClassA: " << objA.dataA << std::endl;
std::cout << "Friend Function: Accessing data from ClassB: " << objB.dataB << std::endl;
}
int main() {
ClassA objA;
ClassB objB;
objA.setDataA(30);
objB.setDataB(50);
// Call the friend function with objects of both classes
friendFunction(objA, objB);
return 0;
}

Output:

Characteristics of Friend Function in C++

• Not a Member of the Class: Despite its friend declaration, a function is not a part of the class for which it was created. Like every other C++ function, it is defined outside of the class.
• Declared Inside the Class: A friend function is declared inside the class but is identified as a friend of the class by the friend keyword. Usually, the private or protected portion of the class contains this declaration.
• Access to Private and Protected Members: Friend functions have access to the private and protected members of the class for which they are designated friends. This enables the function to change the class’s internal state.
• Friendship Is Not Inherited: Friendship isn’t passed down. This means that even while Class C inherits from Class A and Class A declares Class B as a friend, Class C does not immediately have access to Class B’s private members as a result of their friendship.
• Global or Scoped Functions: Friend functions can be global or namespace-defined. They could also belong to several classes, in which case they could have access to various classes’ private and protected members.
• No Implicit ‘this’ Pointer: Unlike member functions, friend functions are not connected to a particular class object. Hence, they lack an implicit pointer. If they need access to the members of a specific object, explicit object references must be given to them as arguments.

Restrictions and Best Practices

The private and protected members of a class can be accessed using friend functions in C++, but there are some restrictions and best practices to follow to ensure proper usage.

Here are some restrictions and best practices for friend functions in C++:

Restrictions

1. Limited Encapsulation: Friend functions give access to a class’s protected and private members but should only be used in moderation. The encapsulation principle of object-oriented programming can be broken by the excessive use of buddy functions, making the code more difficult to comprehend and maintain.
2. Dependency: Friend functions create tight coupling between classes, making it difficult to maintain when modifying the class whose members the function accesses.
3. Security: Care should be taken when using friend functions. Giving private members full access may jeopardize the confidentiality and integrity of the class’s data. Always think about whether it is safe and necessary to expose particular members.
4. Global Scope: Friend functions are defined in the global scope, even though they exist outside the class. If not handled appropriately, especially in bigger codebases, this might result in naming conflicts.

Best Practices

1. Minimize Use: Use friend functions sparingly and only when it is absolutely necessary for an external function or class to get access to a class’s private or protected members. Please do not use them as a convenience to quickly access members.
2. Limited Visibility: Declare friend functions with the narrowest scope possible with limited visibility. Instead of allowing access to all private members, declare a function from another class as a buddy function with the precise private members required.
3. Documentation: Clearly state the function of friend functions, their necessity, and the individuals to whom they are accessible. This aids in comprehending design choices and buddy function usage by other developers.
4. Use Accessor Functions: Instead of establishing accessor functions (getters and setters) within the class to allow controlled access to these members, instead of making all private members accessible through friend functions. Encapsulation is maintained, and data control is improved.
5. Testing and Debugging: Friend functions can be helpful for unit testing and debugging, but keep their usage to these limited circumstances and avoid including them in production code.
6. Reevaluate Class Design: If you frequently use friend functions, your class design may need reevaluation. Consider whether dividing the class into smaller, more specialized classes with proper encapsulation would be preferable.

Common Mistakes in C++ Friend Functions

It’s essential to be aware of the common mistakes when using friend functions in C++ to avoid unexpected issues. Here are some common mistakes and debugging tips related to C++ friend functions:

Common Mistakes When Using Friend Functions:

1. Overusing Friend Functions: One of the most frequent errors is overusing friend functions. Exposing a class’ private members to too many external methods or classes can break encapsulation and make code maintenance more challenging. It’s essential only to use friend functions when necessary.
2. Inadequate Encapsulation: To avoid encapsulation, developers may employ friend functions. They use buddy functions instead of legitimate member functions to access and alter class data. This defeats encapsulation’s intended aim of safeguarding the integrity of class data.
3. Data Exposure: Exercise caution when exposing more information to friend functions than is necessary. Don’t friend the entire class if a method only wants access to a single data member. Ensure you keep the access scope to a minimum.
4. Changing Friend Functions: You might need to go back and edit a class’s friend functions if you change the structure or behavior of the class. Compatibility problems may result from failure to do so.

Debugging Friend Function Issues

1. Access Violations: Check that the friend function declaration is accurate inside the class specification if you have access violations or runtime issues connected to friend functions. Verify that the friend keyword correctly defines the friend function.
2. Issues with Scope: Ensure the friend function is declared and defined appropriately to avoid scope-related problems. Make sure it has access to the class members it should. Depending on the use case, It should be declared in the same namespace or inside the class.
3. Issues with Friend Classes: If you combine friend functions and classes, be sure that the declarations of the friend class and the friend function are accurate in the class that gives friendship.
4. Reviewing the Necessity of Friend Functions: If you’re having problems with friend functions, consider whether they’re necessary. Do any other approaches that would accomplish your objectives without sacrificing encapsulation? Reconsider whether using a friend feature is the best course of action.
5. Testing and Debugging: Carefully test your code, particularly how friend functions interact. To follow the execution path and examine variable values inside the friend function, use debugging tools like breakpoints and logging.
6. Code Examine: Ask coworkers or peers with C++ experience to examine your code. They might catch problems you might have missed with your friend’s functions.

Alternative Approaches of Friend Function in C++

Alternatives to Friend Functions

1. Public Member Functions: Instead of Friend functions, your class can have public member functions that grant controlled access to private or protected members. Many people choose this strategy because it preserves encapsulation and provides a clear interface to outside users.
2. Getters and Setters: You can build getter and setter methods in your class if you need external access to some private members. You can access the values of private members using getter methods and change their values while imposing rules or restrictions using setter methods.
3. Operator Overloading within the Class: If your class has any overloaded operators, you might want to implement them as member functions. This strategy does away with the requirement for friend functions and follows object-oriented principles.
4. Friend Classes: If you discover that several classes require access to each other’s secret members, you might consider adding those classes as friends. This permits particular classes to share private members while yet maintaining some encapsulation.
5. Public Inheritance: You can use public inheritance to generate a new class that will inherit the base class’s public and protected members if you need access to the base class’s members.

When Not to Use Friend Functions?

1. Overuse for Convenience: Utilising friend functions excessively out of convenience or laziness is not a good idea. Overusing them can reduce encapsulation and make it more difficult to maintain code.
2. Exposing Too Much: Consider revising your class design if you have to add multiple friends to a class, as it may indicate a problem. Too much exposure via friend functions may result in losing access control.
3. Security Issues: If security and data integrity are important, refrain from employing friend functions to grant restricted access to private members to external functions. This may result in data corruption or security flaws.
4. Violation of the Single Responsibility Principle: Keeping a function independent from the class in question is often preferable to designating it as a friend function if its principal responsibility is unrelated to the class in question. Breaking the single responsibility principle can make the code less maintainable.
5. Lack of Justification: Suppose there is no compelling justification to use buddy functions, such as the necessity for access to secret members for optimization or operator overloading. Using the previously mentioned alternatives can promote improved code organization and encapsulation, making them a better option to rely on.

Conclusion

A distinctive and adaptable construct in the complex world of C++ programming, friend functions stand out. They provide controlled access to secret and protected members by bridging the gap between class borders and external functions. While providing freedom for collaboration, friend functions also necessitate careful thought.

They provide a means to improve the organization of the code, encourage cooperation between classes, and handle challenging situations. You should restrain their use to maintain encapsulation and the code’s readability. Developers may write well-structured, maintainable code that balances data security and efficient interaction by wisely utilizing the capabilities of buddy functions.

FAQs

Q1. Can friend functions be overloaded or overridden?

Ans: Friend functions cannot be overridden because they are not a part of the class hierarchy, although they can be overloaded.

Q2. Are friend functions recommended in C++ programming?

Ans: Although friend functions have many uses, using them carefully is vital. Overusing friend functions can undermine encapsulation and reduce the maintainability of the code. They ought to be applied as required to fulfill a particular design objective.

Q3. Can a friend function as a member of another class?

Ans: A friend function may belong to another class. The secret members of the class that this class has designated as a friend can then be accessed.

Recommended Articles

We hope that this EDUCBA information on “Friend Function in C++” was beneficial to you. You can view EDUCBA’s recommended articles for more information.

1. Recursive Function in C++
2. Ceil function in C++
3. Recursive Function in C++
4. Operator Overloading in C++