C++ Friend Functions

Introduction

Friend functions in C++ allow you to grant a non-member function access to the private and protected members of a class. By declaring a function as a friend of a class, you enable that function to operate on the internal state of class objects, providing flexibility in designing your classes and functions.

Defining Friend Functions

To define a friend function, you declare it inside the class using the friend keyword. The function is defined outside the class like a regular non-member function but has access to the class’s private and protected members.

Example: Basic Friend Function

Let’s create a simple example with a Box class and a friend function printBox that accesses the private members of the Box class.

#include <iostream>
using namespace std;

class Box {
private:
    double width;
    double height;
    double depth;

public:
    // Constructor to initialize dimensions
    Box(double w, double h, double d) : width(w), height(h), depth(d) {}

    // Declare the friend function
    friend void printBox(const Box& b);
};

// Friend function definition
void printBox(const Box& b) {
    cout << "Box dimensions: " << b.width << " x " << b.height << " x " << b.depth << endl;
}

int main() {
    // Create a Box object
    Box box(3.0, 4.0, 5.0);

    // Call the friend function to print the box dimensions
    printBox(box);

    return 0;
}

Output

Box dimensions: 3 x 4 x 5

Explanation

• The Box class has private members width, height, and depth.
• The friend function printBox is declared inside the Box class using the friend keyword.
• The printBox function is defined outside the class and can access the private members of the Box class.
• The main function creates a Box object and calls the printBox function to print the box dimensions.

Practical Examples

Example 1: Friend Function for Complex Number Addition

Let’s create a Complex class representing complex numbers and a friend function addComplex to add two complex numbers.

#include <iostream>
using namespace std;

class Complex {
private:
    double real;
    double imag;

public:
    // Constructor to initialize real and imaginary parts
    Complex(double r, double i) : real(r), imag(i) {}

    // Declare the friend function
    friend Complex addComplex(const Complex& c1, const Complex& c2);

    // Method to print the complex number
    void print() const {
        cout << real << " + " << imag << "i" << endl;
    }
};

// Friend function definition
Complex addComplex(const Complex& c1, const Complex& c2) {
    return Complex(c1.real + c2.real, c1.imag + c2.imag);
}

int main() {
    // Create two Complex objects
    Complex c1(3.0, 4.0);
    Complex c2(1.0, 2.0);

    // Add the two Complex objects using the friend function
    Complex c3 = addComplex(c1, c2);

    // Print the result
    c3.print();

    return 0;
}

Output

4 + 6i

Explanation

• The Complex class has private members real and imag.
• The friend function addComplex is declared inside the Complex class and defined outside the class. It can access the private members of the Complex class.
• The main function creates two Complex objects, adds them using the addComplex function, and prints the result.

Example 2: Friend Class

In addition to friend functions, you can declare an entire class as a friend of another class. This grants all member functions of the friend class access to the private and protected members of the other class.

#include <iostream>
using namespace std;

class Rectangle {
private:
    double width;
    double height;

public:
    // Constructor to initialize dimensions
    Rectangle(double w, double h) : width(w), height(h) {}

    // Declare the friend class
    friend class AreaCalculator;
};

// Friend class definition
class AreaCalculator {
public:
    // Method to calculate the area of a rectangle
    double calculateArea(const Rectangle& rect) {
        return rect.width * rect.height;
    }
};

int main() {
    // Create a Rectangle object
    Rectangle rect(4.0, 5.0);

    // Create an AreaCalculator object
    AreaCalculator calculator;

    // Calculate and print the area of the rectangle
    cout << "Area of the rectangle: " << calculator.calculateArea(rect) << endl;

    return 0;
}

Output

Area of the rectangle: 20

Explanation

• The Rectangle class has private members width and height.
• The AreaCalculator class is declared as a friend of the Rectangle class, granting it access to the private members of Rectangle.
• The calculateArea method of AreaCalculator calculates the area of a Rectangle object.
• The main function creates a Rectangle object and an AreaCalculator object, then calculates and prints the area of the rectangle.

Guidelines for Using Friend Functions

1. Use Sparingly: Friend functions break the encapsulation of a class by accessing its private members, so use them sparingly and only when necessary.
2. Maintain Readability: Ensure that the use of friend functions does not make the code difficult to understand or maintain.
3. Friend Classes: Use friend classes when multiple functions in a class need access to the private members of another class.

Example: Friend Function for Vector Operations

Let’s create a Vector class representing a 2D vector and a friend function dotProduct to calculate the dot product of two vectors.

#include <iostream>
using namespace std;

class Vector {
private:
    double x;
    double y;

public:
    // Constructor to initialize coordinates
    Vector(double xCoord, double yCoord) : x(xCoord), y(yCoord) {}

    // Declare the friend function
    friend double dotProduct(const Vector& v1, const Vector& v2);

    // Method to print the vector
    void print() const {
        cout << "Vector(" << x << ", " << y << ")" << endl;
    }
};

// Friend function definition
double dotProduct(const Vector& v1, const Vector& v2) {
    return (v1.x * v2.x + v1.y * v2.y);
}

int main() {
    // Create two Vector objects
    Vector v1(3.0, 4.0);
    Vector v2(1.0, 2.0);

    // Calculate the dot product using the friend function
    double result = dotProduct(v1, v2);

    // Print the result
    cout << "Dot product: " << result << endl;

    return 0;
}

Output

Dot product: 11

Explanation

• The Vector class has private members x and y.
• The friend function dotProduct is declared inside the Vector class and defined outside the class. It can access the private members of the Vector class.
• The main function creates two Vector objects, calculates the dot product using the dotProduct function, and prints the result.

Conclusion

Friend functions in C++ provide a way to grant non-member functions access to the private and protected members of a class. They enhance flexibility in designing classes and functions, allowing operations that require access to the internal state of class objects. This chapter covered the basics of defining friend functions, practical examples, and guidelines for their use. Understanding and effectively using friend functions is essential for writing flexible and maintainable C++ programs.