Can you use friend functions to overload operators?

Answer 1

Yes you can. Although you will often hear it said that friend functions undermine encapsulation, this is errant nonsense. Here's a typical example:

#include <iostream>

using namespace std;

class Date

{

private:

int mo, da, yr;

public:

Date( int m, int d, int y ): mo(m), da(d), yr(y) {}

friend ostream& operator<<(ostream& os, const Date& dt);

};

ostream& operator<<(ostream& os, const Date& dt)

{

os << dt.mo << '/' << dt.da << '/' << dt.yr;

return os;

}

int main()

{

Date dt( 5, 6, 92 );

cout << dt;

return( 0 );

}

While it is possible to eliminate the friend function declaration simply by providing public accessors to Date::mo, Date::da and Date::yr, there is no advantage in doing so. You can still provide those accessors, of course, but since you'd need to return those members by value in order to maintain encapsulation, the operator overload would be less efficient as a result. In this case the difference is minimal but, with more complex members, the inefficiency can quickly add up.

Remember that friend functions merely extend the class interface. While it is true that you should not grant friend access to code that you have no control over (and thus undermine any concept of encapsulation), operator overloads such as the insertion operator overload shown above is under your complete control. Ultimately, if it were possible to declare the function as an actual member of the class then you would rightly do so. But that's precisely what you do when you declare friendship. And in this case, that friendship is perfectly legitimate because the alternative, non-friend function, would be less efficient.

Answer 2

While overloading operators using member function it takes only one arguments(other pass implicitly)...

but in case of friend fuction two parameters are required..

Answer 3

When the operator cannot be implemented as a member function of the class, and the operator requires access to some or all of the private members of the class.