When should you use ' friend ' in C++?

In C++ programming, the use of the "friend" keyword can be beneficial in specific scenarios, as it primarily allows certain external functions or other classes to access the private or protected members of the current class. This is commonly used in the following cases:

1. Operator Overloading: When overloading certain operators for a class, friend functions are typically employed. For example, overloading input and output operators (<< and >>), as the left operand of these operators usually requires a stream object rather than a custom type.

   Example:

   cpp
   class Complex {
   private:
       double real, imag;
   public:
       Complex(double r=0.0, double i=0.0) : real(r), imag(i) {}
       friend std::ostream& operator<<(std::ostream& out, const Complex& c);
   };
   
   std::ostream& operator<<(std::ostream& out, const Complex& c) {
       out << c.real << "+" << c.imag << "i";
       return out;
   }

2. Implementing Utility Functions: When utility global functions need to access the private data members of a class, define these functions as friend functions.

   Example:

   cpp
   class Rectangle {
   private:
       double width, height;
   public:
       Rectangle(double w=0.0, double h=0.0) : width(w), height(h) {}
       friend double area(const Rectangle& r);
   };
   
   double area(const Rectangle& r) {
       return r.width * r.height;
   }

3. Implementing Tight Collaboration Between Classes: Sometimes two classes require mutual access to each other's private members, but you do not want to expose these members. In this case, declare one class as a friend of the other.

   Example:

   cpp
   class ClassA {
       friend class ClassB;  // ClassB is a friend of ClassA
   private:
       int data;
   public:
       ClassA() : data(100) {}
   };
   
   class ClassB {
   public:
       void function(const ClassA& a) {
           std::cout << "Data: " << a.data << std::endl;  // Can access ClassA's private data
       }
   };

Using the "friend" keyword can enhance the flexibility and efficiency of the program, but it requires caution as it compromises the encapsulation and data hiding of the class, potentially making the code harder to maintain and understand. Therefore, it is recommended to use friend relationships only when absolutely necessary.