Friend keyword

In the previous section we have seen that there were three levels of internal protection for the different members of a class: public, protected and private. In the case of members protected and private, these could not be accessed from outside the same class at which they are declared. Nevertheless, this rule can be transgressed with the use of the friend keyword in a class, so we can allow an external function to gain access to the protected and private members of a class.
In order to allow an external function to have access to the private and protected members of a class we have to declare the prototye of the external function that will gain access preceded by the keyword friend within the class declaration that shares its members. In the following example we declare the friend function duplicate:

// friend functions

#include <iostream.h>

class CRectangle {

    int width, height;

  public:

    void set_values (int, int);

    int area (void) {return (width * height);}

    friend CRectangle duplicate (CRectangle);

};

void CRectangle::set_values (int a, int b) {

  width = a;

  height = b;

}

CRectangle duplicate (CRectangle rectparam)

{

  CRectangle rectres;

  rectres.width = rectparam.width*2;

  rectres.height = rectparam.height*2;

  return (rectres);

}

int main () {

  CRectangle rect, rectb;

  rect.set_values (2,3);

  rectb = duplicate (rect);

  cout << rectb.area();

}

From within the duplicate function, that is a friend of CRectangle, we have been able to access the members width and height of different objects of type CRectangle. Notice that neither in the declaration of duplicate() nor in its later use in main() have we considered duplicate as a member of class CRectangle. It isn't.
The friend functions can serve, for example, to conduct operations between two different classes. Generally the use of friend functions is out of an object-oriented programming methodology, so whenever possible it is better to use members of the same class to make the process. Such as in the previous example, it would have been shorter to integrate duplicate() within the class CRectangle.

Friend classes (friend)

Just as we have the possibility to define a friend function, we can also define a class as friend of another one, allowing that the second one access to the protected and private members of the first one.

// friend class

#include <iostream.h>

class CSquare;

class CRectangle {

    int width, height;

  public:

    int area (void)

      {return (width * height);}

    void convert (CSquare a);

};

class CSquare {

  private:

    int side;

  public:

    void set_side (int a)

      {side=a;}

    friend class CRectangle;

};

void CRectangle::convert (CSquare a) {

  width = a.side;

  height = a.side;

}

int main () {

  CSquare sqr;

  CRectangle rect;

  sqr.set_side(4);

  rect.convert(sqr);

  cout << rect.area();

  return 0;

}

In this example we have declared CRectangle as a friend of CSquare so that CRectangle can access the protected and private members of CSquare, more concretely CSquare::side, that defines the square side width.
You may also see something new in the first instruction of the program, that is the empty prototype of class CSquare. This is necessary because within the declaration of CRectangle we refer to CSquare (as a parameter in convert()). The definition of CSquare is included later, so if we did not include a previous definition for CSquare this class would not be visible from within the definition of CRectangle.
Consider that friendships are not corresponded if we do not explicitly specify it. In our CSquare example CRectangle is considered as a class friend, but CRectangle does not do the proper thing with CSquare, so CRectangle can access to the protected and private members of CSquare but not the reverse way. Although nothing prevents us from declaring CSquare as a friend of CRectangle.