C++ Friend Functions
In C++, friends are special functions that are not a part of a class yet have access to its private and protected members. The friend keyword is used to declare such a function inside the class.
Friend functions are useful when we need to grant secret data access to other functions (or other classes) without explicitly revealing it.
Key Points:
- It is specified inside a class using the buddy keyword.
- Defined outside of the class as an ordinary function.
- It can get in touch with protected and private class members.
- Since it is not considered a member of the class, it is called a normal function.
Algorithm:
Below are the different steps need to be followed by the friend function in C++:
- Define a class with private members.
- Declare a friend function inside the class using the friend keyword.
- Define the friend function outside the class.
- Create an object of the class in main().
- Call the friend function, passing the class object as an argument.
- Access and manipulate private data within the friend function.
Pseudo code:
START 1. Define a class ‘MyClass’ 2. Declare a private data member ‘data’ 3. Create a public constructor to initialize ‘data’ 4. Declare a friend function ‘displayData(obj)’ inside the class - This function will access private members 5. Define the friend function ‘displayData(obj)’ outside the class - Print the value of ‘data’ 6. In ‘main()’ function: a. Create an object ‘obj’ of ‘MyClass’ and initialize it b. Call ‘displayData(obj)’, passing the object 7. The friend function accesses and displays the private data END
Example 1:
Let us take an example to illustrate the Friend Function in C++.
#include <iostream>
using namespace std;
class MyClass {
private:
int data; // Private member
public:
// Constructor to initialize private data
MyClass(int value) : data(value) {}
// Friend function declaration
friend void displayData(const MyClass& obj);
};
// Friend function definition (outside the class)
void displayData(const MyClass& obj) {
// Accessing private member of MyClass
cout << "Private Data: " << obj.data << endl;
}
int main() {
MyClass obj(10); // Creating object with value 10
displayData(obj); // Calling friend function
return 0;
}
Output:
Private Data: 10
Explanation:
- Member of Private Data: MyClass is a class that contains private integer data.
- Declaration of the Friend Function: The displayData() is declared as a friend function inside MyClass.
- What the Friend Function Is: It has data access capabilities and is defined outside of the class.
- Object Creation: The displayData(obj) is called following the creation of an object, obj, in main().
- Accessing Private Data: Once the function has successfully obtained access to the private data, it prints the contents.
Example 2:
Let us take another example using a friend function to Add Two private Data Members from Different classes in C++.
#include <iostream>
using namespace std;
class ClassB; // Forward declaration
class ClassA {
private:
int numA;
public:
// Constructor to initialize numA
ClassA(int value) : numA(value) {}
// Friend function declaration
friend int addNumbers(const ClassA& objA, const ClassB& objB);
};
class ClassB {
private:
int numB;
public:
// Constructor to initialize numB
ClassB(int value) : numB(value) {}
// Friend function declaration
friend int addNumbers(const ClassA& objA, const ClassB& objB);
};
// Friend function definition (outside both classes)
int addNumbers(const ClassA& objA, const ClassB& objB) {
return objA.numA + objB.numB; // Accessing private members
}
int main() {
ClassA objA(5); // Object of ClassA with value 5
ClassB objB(10); // Object of ClassB with value 10
cout << "Sum: " << addNumbers(objA, objB) << endl; // Calling friend function
return 0;
}
Output:
Sum: 15
Explanation:
- Two classes (Class A and Class B) have private data members (numA and numB).
- The Friend Function (addNumbers()) is defined by both classes.
- Friend’s function’s definition: It obtains the sum of each classes’ private data members.
- Creation of Objects: Both classes’ objects are created and initialized with values by Main().
- Call to Function: addNumbers(objA, objB) calculates the sum of numA and numB.
Usage of Friend Functions:
- When an external function needs access to private data.
- When some operators (like operator+ and operator<<) are overloaded.
- When two or more classes need to communicate sensitive information.
Conclusion:
In conclusion, the friend function is a useful feature in C++ that allows outside functions to access a class’s private and protected members without actually being a part of that class. It is declared inside the class using the friend keyword and defined outside of it, just like any other function. Friend functions are very helpful for activities like operator overloading and inter-class communication that need access to secret information. However, using buddy functions excessively can undermine encapsulation and reduce the maintainability of code. In order to balance data security with flexibility, they should be utilized rarely. Programmers can write more organized and efficient C++ programs by controlling access to class members by understanding buddy functions.