Understanding Friend Function in C++: Concept, Syntax, and Practical Examples

Understanding Friend Function in C++: Concept, Syntax, and Practical Examples

• 

  Ms. Sonal Rana / 3 days ago
• 0
• 6 min read

What is a Friend Function?

A friend function is a function that is not a member of a class but has the privilege to access its private and protected members. It allows for controlled sharing of data between classes or functions without violating object-oriented design.

Key Characteristics:

• Declared inside a class using the friend keyword.
• Defined like a regular function outside the class.
• Can access all private and protected members of the class.
• Useful in operator overloading, utility functions, and inter-class operations.

Syntax of a Friend Function

Here’s the basic syntax of a friend function:

                        Thread t = new Thread(); // Thread is in the New stateclass ClassName {
                         friend ReturnType FunctionName(Arguments);
                        };

                    

Although it's declared inside the class, it’snot a member function and is defined separately outside the class body.

Example: Friend Function in Use

Let’s look at a simple example to illustrate the use of a friend function.

Scenario:

You have a class Sample that contains a private data member. You want a function displayData() to access and display that private data.

Code:

                        #include 
                        using namespace std;

                        class Sample {
                        private:
                            int data;

                        public:
                            Sample() : data(10) {}

                            // Friend function declaration
                            friend void displayData(Sample s);
                        };

                        // Friend function definition
                        void displayData(Sample s) {
                            cout << "Data: " << s.data << endl;
                        }

                        int main() {
                            Sample obj;
                            displayData(obj);
                            return 0;
                        }
                       


                    

Output:

                       Data: 10

                    

Real-World Example: Two Classes Working Together

Suppose you want a function to access private members from one class and operate in another. Let’s say you have a Box class and you want a friend function showDimensions to display its private data.

                        #include 
                        using namespace std;

                        class Box {
                        private:
                            int length;
                            int width;

                        public:
                            Box(int l, int w) : length(l), width(w) {}

                            // Declare friend function
                            friend void showDimensions(Box b);
                        };

                        void showDimensions(Box b) {
                            cout << "Length: " << b.length << endl;
                            cout << "Width: " << b.width << endl;
                        }

                        int main() {
                            Box myBox(10, 5);
                            showDimensions(myBox);
                            return 0;
                        }


                    

Output

                        Length: 10
                        Width: 5


                    

Friend Class

Beyond individual functions, you can declare an entire class as a friend to give all its methods access to private members of another class.

Example

                        class B;

                        class A {
                        private:
                            int value;

                        public:
                            A() : value(100) {}

                            friend class B;
                        };

                        class B {
                        public:
                            void showValue(A a) {
                                cout << "Value from class A: " << a.value << endl;
                            }
                        };



                    

Advantages of Using Friend Functions

• Controlled Access:Enables controlled access to private data without exposing it to everyone.
• Operator Overloading:Helps with binary operators as non-member functions.
• Flexibility:Useful when implementing utility functions that need direct access.

Drawbacks to Consider

• Breaks Encapsulation:It goes against the strict rules of object-oriented design.
• Tight Coupling:Overuse can result in tightly coupled code, which is harder to maintain.
• Harder to Manage:Keeping track of all friend relationships can become complex in large projects.

When to Use Friend Functions

Use friend functions when:

• Operator overloading can't be implemented as a member function.
• External functions need specific, limited access to internal class data.
• Two or more classes need to work closely with each other's private data.

Elevate Your Programming Career: Learn Software Testing!

If you’re exploring C++ and its deeper concepts like friend functions, you're already on the right track toward becoming a skilled developer. But writing code is only half the battle—ensuring your code is tested and reliable is just as important.

Enroll in Our Software Testing Course and Learn:

• Manual & Automated Testing Techniques
• Popular Tools: Selenium, JUnit, TestNG
• Industry Best Practices
• Project-Based Learning with Certification
• Job-Ready Training & Career Support

Master testing skills that employers demand and become a complete software professional.

Ready to upgrade your tech journey? [Enroll Now in the Software Testing Course]

Final Thoughts

Friend functions in C++ offer a unique way to balance encapsulation and flexibility. When used wisely, they can enhance collaboration between classes and functions. Whether you're aiming to deepen your programming expertise or step into software QA, understanding such foundational concepts is key.

Start coding smart—and testing smarter.