Friend Function And Friend Class (friend Keyword) in C++

In C++, friend functions and friend classes provide a way to access private and protected members of a class from outside the class scope. Friend functions are not member functions of the class but can access private and protected members. A friend class is a class whose member functions are allowed to access the private and protected members of another class.

In this tutorial, we'll cover the basics of friend functions and friend classes in C++.

Friend Functions:

To declare a friend function for a class, use the friend keyword followed by the function declaration inside the class definition. A friend function can be a global function or a member function of another class.

Example:

#include <iostream>

class Circle {
private:
    double radius;

public:
    Circle(double r) : radius(r) {}

    // Friend function declaration
    friend double calculateArea(const Circle& c);
};

double calculateArea(const Circle& c) {
    return 3.14159265359 * c.radius * c.radius;
}

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

Friend Classes:

To declare a friend class, use the friend keyword followed by the class name inside the class definition. All member functions of the friend class can access the private and protected members of the class that declares it as a friend.

Example:

#include <iostream>

class Circle {
private:
    double radius;

public:
    Circle(double r) : radius(r) {}

    // Friend class declaration
    friend class CircleUtilities;
};

class CircleUtilities {
public:
    static double calculateArea(const Circle& c) {
        return 3.14159265359 * c.radius * c.radius;
    }

    static double calculateCircumference(const Circle& c) {
        return 2 * 3.14159265359 * c.radius;
    }
};

int main() {
    Circle circle(5.0);
    std::cout << "Area of the circle: " << CircleUtilities::calculateArea(circle) << std::endl;
    std::cout << "Circumference of the circle: " << CircleUtilities::calculateCircumference(circle) << std::endl;
    return 0;
}

In both examples, the friend function calculateArea() and the friend class CircleUtilities can access the private member radius of the Circle class. This demonstrates how friend functions and friend classes can access private and protected members of a class. However, use friend functions and friend classes judiciously, as they can break encapsulation and make the code harder to maintain.

How to use the friend keyword in C++:

The friend keyword in C++ is used to grant access to private or protected members of a class to external functions or classes. Example:

#include <iostream>

class MyClass {
private:
    int privateData;

public:
    MyClass(int data) : privateData(data) {}

    friend void displayPrivateData(const MyClass& obj);
};

// Friend function definition
void displayPrivateData(const MyClass& obj) {
    std::cout << "Private data: " << obj.privateData << std::endl;
}

int main() {
    MyClass myObject(42);

    // Access private data using friend function
    displayPrivateData(myObject);

    return 0;
}

Friend function vs friend class in C++:

In C++, a friend function is a standalone function granted access to the private members of a class, while a friend class is a class that is given access to the private and protected members of another class. Example:

#include <iostream>

class MyClass {
private:
    int privateData;

    friend void friendFunction(const MyClass& obj);
    friend class FriendClass;
};

// Friend function definition
void friendFunction(const MyClass& obj) {
    std::cout << "Private data from friend function: " << obj.privateData << std::endl;
}

// Friend class definition
class FriendClass {
public:
    void accessPrivateData(const MyClass& obj) {
        std::cout << "Private data from friend class: " << obj.privateData << std::endl;
    }
};

int main() {
    MyClass myObject(42);

    // Access private data using friend function
    friendFunction(myObject);

    // Access private data using friend class
    FriendClass friendObj;
    friendObj.accessPrivateData(myObject);

    return 0;
}

Accessing private members with friend functions in C++:

Friend functions can access private members of a class, providing a way to encapsulate data while allowing specific functions to work with it. Example:

#include <iostream>

class MyClass {
private:
    int privateData;

    friend void friendFunction(const MyClass& obj);

public:
    MyClass(int data) : privateData(data) {}
};

// Friend function definition
void friendFunction(const MyClass& obj) {
    std::cout << "Accessing private data: " << obj.privateData << std::endl;
}

int main() {
    MyClass myObject(42);

    // Access private data using friend function
    friendFunction(myObject);

    return 0;
}

Creating friend classes for encapsulation in C++:

Friend classes in C++ can be used to allow another class to access private and protected members, enhancing encapsulation. Example:

#include <iostream>

class FriendClass;

class MyClass {
private:
    int privateData;

    friend class FriendClass;

public:
    MyClass(int data) : privateData(data) {}
};

// Friend class definition
class FriendClass {
public:
    void accessPrivateData(const MyClass& obj) {
        std::cout << "Accessing private data: " << obj.privateData << std::endl;
    }
};

int main() {
    MyClass myObject(42);

    // Access private data using friend class
    FriendClass friendObj;
    friendObj.accessPrivateData(myObject);

    return 0;
}

Friendship in C++ classes and functions:

Friendship in C++ allows certain functions or classes to access the private and protected members of a class. Example:

#include <iostream>

class FriendClass;

class MyClass {
private:
    int privateData;

    friend void friendFunction(const MyClass& obj);
    friend class FriendClass;

public:
    MyClass(int data) : privateData(data) {}
};

// Friend function definition
void friendFunction(const MyClass& obj) {
    std::cout << "Accessing private data from friend function: " << obj.privateData << std::endl;
}

// Friend class definition
class FriendClass {
public:
    void accessPrivateData(const MyClass& obj) {
        std::cout << "Accessing private data from friend class: " << obj.privateData << std::endl;
    }
};

int main() {
    MyClass myObject(42);

    // Access private data using friend function
    friendFunction(myObject);

    // Access private data using friend class
    FriendClass friendObj;
    friendObj.accessPrivateData(myObject);

    return 0;
}

Friend functions and operator overloading in C++:

Friend functions are often used for operator overloading, allowing custom behavior for user-defined types. Example:

#include <iostream>

class ComplexNumber {
private:
    double real;
    double imag;

public:
    ComplexNumber(double r, double i) : real(r), imag(i) {}

    // Friend function for operator overloading
    friend ComplexNumber operator+(const ComplexNumber& lhs, const ComplexNumber& rhs);
};

// Friend function definition
ComplexNumber operator+(const ComplexNumber& lhs, const ComplexNumber& rhs) {
    return ComplexNumber(lhs.real + rhs.real, lhs.imag + rhs.imag);
}

int main() {
    ComplexNumber num1(1.0, 2.0);
    ComplexNumber num2(3.0, 4.0);

    // Operator overloading using friend function
    ComplexNumber result = num1 + num2;

    return 0;
}

Friend class and inheritance in C++:

Friend classes in C++ can be used in the context of inheritance, allowing a derived class to access the private and protected members of its base class. Example:

#include <iostream>

class BaseClass {
private:
    int privateData;

    friend class DerivedClass;
};

class DerivedClass : public BaseClass {
public:
    void accessBaseData(const BaseClass& obj) {
        std::cout << "Accessing private data from derived class: " << obj.privateData << std::endl;
    }
};

int main() {
    DerivedClass derivedObj;

    // Access private data from the derived class
    derivedObj.accessBaseData(BaseClass());

    return 0;
}

Friend function and const-correctness in C++:

Friend functions in C++ can be declared as const to support const-correctness, allowing them to be called on const objects. Example:

#include <iostream>

class MyClass {
private:
    int privateData;

    friend void friendFunction(const MyClass& obj);

public:
    MyClass(int data) : privateData(data) {}
};

// Friend function definition with const-correctness
void friendFunction(const MyClass& obj) {
    std::cout << "Accessing private data: " << obj.privateData << std::endl;
}

int main() {
    const MyClass myObject(42);

    // Access private data using friend function with const object
    friendFunction(myObject);

    return 0;
}

Friend classes and templates in C++:

Friend classes can be used in conjunction with templates in C++ to allow specific template instantiations to access private members. Example:

#include <iostream>

template <typename T>
class MyClass {
private:
    T privateData;

    template <typename U>
    friend class FriendClass;
};

template <typename U>
class FriendClass {
public:
    void accessPrivateData(const MyClass<U>& obj) {
        std::cout << "Accessing private data: " << obj.privateData << std::endl;
    }
};

int main() {
    MyClass<int> myObject;

    // Access private data using friend class and template
    FriendClass<int> friendObj;
    friendObj.accessPrivateData(myObject);

    return 0;
}

Examples of using friend functions and classes in C++:

Friend function example:

#include <iostream>

class MyClass {
private:
    int privateData;

    friend void friendFunction(const MyClass& obj);

public:
    MyClass(int data) : privateData(data) {}
};

// Friend function definition
void friendFunction(const MyClass& obj) {
    std::cout << "Accessing private data: " << obj.privateData << std::endl;
}

int main() {
    MyClass myObject(42);

    // Access private data using friend function
    friendFunction(myObject);

    return 0;
}

Friend class example:

#include <iostream>

class FriendClass;

class MyClass {
private:
    int privateData;

    friend class FriendClass;

public:
    MyClass(int data) : privateData(data) {}
};

// Friend class definition
class FriendClass {
public:
    void accessPrivateData(const MyClass& obj) {
        std::cout << "Accessing private data: " << obj.privateData << std::endl;
    }
};

int main() {
    MyClass myObject(42);

    // Access private data using friend class
    FriendClass friendObj;
    friendObj.accessPrivateData(myObject);

    return 0;
}