Friend Function in C++

GENERAL CONCEPT :

• We know that only member functions can access the PRIVATE data of a class. This is the essence of data-encapsulation.
• However, sometimes we want to make an exception to this rule to avoid programming inconvenience. At such times we allow functions outside a class to access and manipulate class’s data members.
• To achieve this, C++ provides a keyword called ‘friend’.
• It permits a function or all the functions of another class to read and modify original class’s private data members.

DEFINITION :

Therefore, if a function is defined as a friend function in C++ to a class, then the protected and private data of this class can be accessed using this function.

SYNTAX :

(1) Declaration :
    class class_name
    {
        friend data_type function_name(argument/s);            // syntax of friend-funct.
    };

(2) Definition :
    // Just similar as any normal function.
    /* The function definition does not use either the keyword 'friend' or scope 
       resolution operator(::).  */

RULES :

• The concept of friends is not there in Java.
• The declaration of the friend function must be present in the class body.
• It cannot be called using the object (using ‘.’ operator) as it is not in the scope of that class.
• It can be invoked like a normal function without using the object.
• It can be declared either in the private or the public part.
• It cannot access the data-member-names directly and has to use an object name and ‘.’ operator with the member name.

EXAMPLE :

#include<iostream&gt;
using namespace std;

class two;

class one
{
    private :
        int data1;
    public :
        one()
        { data1 = 100;}
        friend access_both(one, two);
};

class two
{
    private :
        int data2;
    public :
        two()
        { data2 = 200;}
        friend access_both(one, two);
};

int access_both(one a, two b)
{
    return (a.data1 + b.data2);
}

int main()
{
    one a;
    two b;
    cout<<access_both(a,b)<<endl;
    return 0;
}

// OUTPUT : 300

NOTE :

Friends should be used only for limited purpose – if too many functions are declared as friends of a class with protected or private data, it lessens the value of encapsulation of classes in object-oriented programming.