FRIEND CLASS IMPLEMENTATION IN CPP EASIEST PROGRAM

Understanding Friend Classes in C++

In C++, encapsulation is a core principle that protects a class's data from outside interference. By making members `private`, we ensure they can only be accessed by the class's own methods. But what if you need to grant special access to another class? That's where the `friend` keyword comes in.

This guide will walk you through the concept of a friend class with a simple, clear example.

---

What is a Friend Class?

A friend class is a class that is granted access to the `private` and `protected` members of another class. When you declare class `B` as a friend of class `A`, class `B` can access all of `A`'s members, no matter their access level.

This creates a tight coupling between the two classes and should be used sparingly, as it intentionally breaks encapsulation. It's useful in specific scenarios, such as when two classes work very closely together and managing their interaction through a public interface would be overly complex.

Important Note: Friendship is a one-way street. If class `B` is a friend of class `A`, it does not mean class `A` is also a friend of class `B`.

---

The Real-Life Example: A Doctor and a Patient

Imagine a Patient class. Your health records, medical history, and personal details are like private members of this class. You wouldn't want just anyone to have access to them.
Now, think of a Doctor class. For the doctor to treat you effectively, they need special permission to access your private medical records.

In C++, the Patient class can declare the Doctor class as a friend. This doesn't make the Doctor a part of the Patient, but it grants the Doctor special access to the Patient's private information. Other classes, like HospitalAdmin or InsuranceAgent, wouldn't have this direct access unless also declared as friends.

This is the essence of a friend class: one class granting full access to its private parts to another, separate class, based on a relationship of trust and necessity.

A Simple C++ Example

Let's look at a clear example. We'll have a class `SecretHolder` with a private data member. Then, we'll create a `FriendClass` that can access this private data.

#include <iostream>

// This class will hold a secret value.
class SecretHolder {
private:
int secretValue;

public:
// Constructor to initialize the secret value.
SecretHolder() {
secretValue = 1000;
}

// Declare FriendClass as a friend.
friend class FriendClass; 

};

// This class is a friend of SecretHolder.
class FriendClass {
public:
// This method can access the private members of SecretHolder.
void displaySecret(SecretHolder& sh) {
std::cout << "FriendClass is accessing the secret value: "
<< sh.secretValue << std::endl;
}
};

int main() {
SecretHolder mySecret;
FriendClass friendObj;

// The friend object's method can access the private data.
friendObj.displaySecret(mySecret);

return 0;

}

Code Breakdown

1. The `SecretHolder` Class: This class has a `private` integer member called `secretValue`. Normally, nothing outside this class could access it.
2. The `friend` Declaration: Inside `SecretHolder`, the line `friend class FriendClass;` tells the compiler that `FriendClass` is trusted and is allowed to access `SecretHolder`'s private and protected members.
3. The `FriendClass` Class: This class has a public method `displaySecret` that takes a reference to a `SecretHolder` object.
4. Accessing Private Data: Inside `displaySecret`, we can directly access `sh.secretValue` because `FriendClass` is a friend of `SecretHolder`. Without the `friend` declaration, this line would cause a compilation error.
5. The `main` Function: We create objects of both classes. We then call the method on the `friendObj`, passing `mySecret` to it, successfully accessing the private data.

Output

FriendClass is accessing the secret value: 1000

• Whatsapp
• Tweet
• Share
• Share
• Share
• Share

Sign up here with your email