When should you use friend in C

Question

I have been reading through the C   FAQ and was curious about the friend declaration  I personally have never used it  however I am interested in exploring the language    What is a good example of using friend     Reading the FAQ a bit longer I like the idea of the  lt  lt   gt  gt  operator overloading and adding as a friend of those classes  However I am not sure how this doesn t break encapsulation  When can these exceptions stay within the strictness that is OOP

User · Answer

roo  Encapsulation is not broken here because the class itself dictates who can access its private members  Encapsulation would only be broken if this could be caused from outside the class  e g  if your operator  lt  lt  would proclaim    I m a friend of class foo      friend replaces use of public  not use of private   Actually  the C   FAQ answers this already

User · Answer

As the reference for friend declaration says      The friend declaration appears in a class body and grants a function or another class access to private and protected members of the class where the friend declaration appears    So just as a reminder  there are technical errors in some of the answers which say that friend can only visit protected members

User · Answer

You have to be very careful about when where you use the friend keyword  and  like you  I have used it very rarely  Below are some notes on using friend and the alternatives   Let s say you want to compare two objects to see if they re equal  You could either    Use accessor methods to do the comparison  check every ivar and determine equality   Or  you could access all the members directly by making them public    The problem with the first option  is that that could be a LOT of accessors  which is  slightly  slower than direct variable access  harder to read  and cumbersome  The problem with the second approach is that you completely break encapsulation   What would be nice  is if we could define an external function which could still get access to the private members of a class  We can do this with the friend keyword   class Beer   public      friend bool equal Beer a  Beer b   private                  The method equal Beer  Beer  now has direct access to a and b s private members  which may be char  brand  float percentAlcohol  etc  This is a rather contrived example  you would sooner apply friend to an overloaded    operator  but we ll get to that   A few things to note    A friend is NOT a member function of the class It is an ordinary function with special access to the private members of the class Don t replace all accessors and mutators with friends  you may as well make everything public   Friendship isn t reciprocal Friendship isn t transitive Friendship isn t inherited Or  as the C   FAQ explains   Just because I grant you friendship access to me doesn t automatically grant your kids access to me  doesn t automatically grant your friends access to me  and doesn t automatically grant me access to you     I only really use friends when it s much harder to do it the other way  As another example  many vector maths functions are often created as friends due to the interoperability of Mat2x2  Mat3x3  Mat4x4  Vec2  Vec3  Vec4  etc  And it s just so much easier to be friends  rather than have to use accessors everywhere  As pointed out  friend is often useful when applied to the  lt  lt   really handy for debugging    gt  gt  and maybe the    operator  but can also be used for something like this   class Birds   public      friend Birds operator   Birds  Birds   private      int numberInFlock       Birds operator   Birds b1  Birds b2        Birds temp      temp numberInFlock   b1 numberInFlock   b2 numberInFlock      return temp      As I say  I don t use friend very often at all  but every now and then it s just what you need  Hope this helps

User · Answer

edit  Reading the faq a bit longer I like the idea of the  lt  lt     operator overloading and adding as a friend of those classes  however I am not sure how this doesn t break encapsulation   How would it break encapsulation   You break encapsulation when you allow unrestricted access to a data member  Consider the following classes   class c1   public    int x      class c2   public    int foo    private    int x      class c3     friend int foo    private    int x       c1 is obviously not encapsulated  Anyone can read and modify x in it  We have no way to enforce any kind of access control   c2 is obviously encapsulated  There is no public access to x  All you can do is call the foo function  which performs some meaningful operation on the class   c3  Is that less encapsulated  Does it allow unrestricted access to x  Does it allow unknown functions access   No  It allows precisely one function to access the private members of the class  Just like c2 did  And just like c2  the one function which has access is not  some random  unknown function   but  the function listed in the class definition   Just like c2  we can see  just by looking at the class definitions  a complete list of who has access   So how exactly is this less encapsulated  The same amount of code has access to the private members of the class  And everyone who has access is listed in the class definition   friend does not  break encapsulation  It makes some Java people programmers feel uncomfortable  because when they say  OOP   they actually mean  Java   When they say  Encapsulation   they don t mean  private members must be protected from arbitrary accesses   but  a Java class where the only functions able to access private members  are class members   even though this is complete nonsense for several reasons   First  as already shown  it is too restricting  There s no reason why friend methods shouldn t be allowed to do the same   Second  it is not restrictive enough  Consider a fourth class   class c4   public    int getx      void setx int x   private    int x       This  according to aforesaid Java mentality  is perfectly encapsulated  And yet  it allows absolutely anyone to read and modify x  How does that even make sense   hint  It doesn t   Bottom line  Encapsulation is about being able to control which functions can access private members  It is not about precisely where the definitions of these functions are located

User · Answer

The canonical example is to overload operator lt  lt    Another common use is to allow a helper or admin class access to your internals   Here are a couple of guidelines I heard about C   friends   The last one is particularly memorable    Your friends are not your child s friends  Your child s friends are not your friends  Only friends can touch your private parts

User · Answer

At work we use friends for testing code  extensively  It means we can provide proper encapsulation and information hiding for the main application code  But also we can have separate test code that uses friends to inspect internal state and data for testing   Suffice to say I wouldn t use the friend keyword as an essential component of your design

User · Answer

You control the access rights for members and functions using Private Protected Public right  so assuming the idea of each and every one of those 3 levels is clear  then it should be clear that we are missing something      The declaration of a member function as protected for example is pretty generic  You are saying that this function is out of reach for everyone  except for an inherited child of course   But what about exceptions  every security system lets you have some type of  white list  right   So friend lets you have the flexibility of having rock solid object isolation  but allows for a  loophole  to be created for things that you feel are justified   I guess people say it is not needed because there is always a design that will do without it  I think it is similar to the discussion of global variables  You should never use them  There is always a way to do without them    but in reality  you see cases where that ends up being the  almost  most elegant way    I think this is the same case with friends      It doesn t really do any good  other than let you access a member variable without using a setting function   well that is not exactly the way to look at it  The idea is to control WHO can access what  having or not a setting function has little to do with it

User · Answer

In C    friend  keyword is useful in Operator overloading and Making Bridge  1   Friend keyword in operator overloading  Example for operator overloading is  Let say we have a class  Point  that has two float variable x  for x-coordinate  and  y  for y-coordinate   Now we have to overload   lt  lt   extraction operator  such that if we call  cout  lt  lt  pointobj  then it will print x and y coordinate  where pointobj is an object of class Point   To do this we have two option     1 Overload  operator  lt  lt     function in  ostream  class     2 Overload  operator lt  lt     function in  Point  class  Now First option is not good because if we need to overload again this operator for some different class then we have to again make change in  ostream  class  That s why second is best option  Now compiler can call  operator  lt  lt     function      1 Using ostream object cout As  cout operator lt lt Pointobj   form ostream class     2 Call without an object As  operator lt lt cout  Pointobj   from Point class    Beacause we have implemented overloading in Point class  So to call this function without an object we have to add friend  keyword because we can call a friend function without an object  Now function declaration will be As        friend ostream  amp operator lt  lt  ostream  amp cout  Point  amp pointobj     2   Friend keyword in making bridge   Suppose we have to make a function in which we have to access private member of two or more classes   generally termed as  bridge      How to do this  To access private member of a class it should be member of that class  Now to access private member of other class every class should declare that function as a friend function  For example   Suppose there are two class A and B  A function  funcBridge    want to access private member of both classes  Then both class should declare  funcBridge    as     friend return type funcBridge A  amp a obj  B  amp  b obj  I think this would help to understand friend keyword

User · Answer

Friend functions and classes provide direct access to private and protected members of class to avoid breaking encapsulation in the general case  Most usage is with ostream  we would like to be able to type   Point p  cout  lt  lt  p    However  this may require access to the private data of Point  so we define the overloaded operator  friend ostream amp  operator lt  lt  ostream amp  output  const Point amp  p     There are obvious encapsulation implications  however  First  now the friend class or function has full access to ALL members of the class  even ones that do not pertain to its needs  Second  the implementations of the class and the friend are now enmeshed to the point where an internal change in the class can break the friend   If you view the friend as an extension of the class  then this is not an issue  logically speaking  But  in that case  why was it necessary to spearate out the friend in the first place   To achieve the same thing that  friends  purport to achieve  but without breaking encapsulation  one can do this   class A   public      void need your data B  amp  myBuddy                myBuddy take this name name          private      string name       class B   public      void print buddy name A  amp  myBuddy                myBuddy need your data  this             void take this name const string  amp  name                cout  lt  lt  name              Encapsulation is not broken  class B has no access to the internal implementation in A  yet the result is the same as if we had declared B a friend of A  The compiler will optimize away the function calls  so this will result in the same instructions as direct access   I think using  friend  is simply a shortcut with arguable benefit  but definite cost

User · Answer

You could adhere to the strictest and purest OOP principles and ensure that no data members for any class even have accessors so that all objects must be the only ones that can know about their data with the only way to act on them is through indirect messages  i e   methods   But even C  has an internal visibility keyword and Java has its default package level accessibility for some things  C   comes actually closer to the OOP ideal by minimizinbg the compromise of visibility into a class by specifying exactly which other class and only other classes could see into it    I don t really use C   but if C  had friends I would that instead of the assembly-global internal modifier  which I actually use a lot  It doesn t really break incapsulation  because the unit of deployment in  NET is an assembly   But then there s the InternalsVisibleToAttribute otherAssembly  which acts like a cross-assembly friend mechanism  Microsoft uses this for visual designer assemblies

User · Answer

When implementing tree algorithms for class  the framework code the prof gave us had the tree class as a friend of the node class   It doesn t really do any good  other than let you access a member variable without using a setting function

User · Answer

One specific instance where I use friend is when creating Singleton classes   The friend keyword lets me create an accessor function  which is more concise than always having a  GetInstance    method on the class                                Header file class MySingleton   private         Private c-tor for Singleton pattern     MySingleton           friend MySingleton amp  GetMySingleton          Accessor function - less verbose than having a  GetInstance         static function on the class MySingleton amp  GetMySingleton                                   Implementation file MySingleton amp  GetMySingleton         static MySingleton theInstance      return theInstance

User · Answer

The creator of C   says that isn t broking any encapsulation principle  and I will quote him      Does  friend  violate encapsulation    No  It does not   Friend  is an explicit mechanism for granting access  just like membership  You cannot  in a standard conforming program  grant yourself access to a class without modifying its source    Is more than clear

User · Answer

Another common version of Andrew s example  the dreaded code-couplet  parent addChild child   child setParent parent     Instead of worrying if both lines are always done together and in consistent order you could make the methods private and have a friend function to enforce consistency   class Parent   class Object   private      void setParent Parent amp         friend void addChild Parent amp  parent  Object amp  child       class Parent   public Object   private       void addChild Object amp  child         friend void addChild Parent amp  parent  Object amp  child       void addChild Parent amp  parent  Object amp  child        if   amp parent     amp child             wetPants               parent addChild child       child setParent parent       In other words you can keep the public interfaces smaller and enforce invariants that cut across classes and objects in friend functions

User · Answer

To do TDD many times I ve used  friend  keyword in C     Can a friend know everything about me     Updated  I found this valuable answer about  friend  keyword from Bjarne Stroustrup site       Friend  is an explicit mechanism for granting access  just like membership

User · Answer

To do TDD many times I ve used  friend  keyword in C   Can a friend know everything about me    No  its only a one way friendship

User · Answer

I m only using the friend-keyword to unittest protected functions  Some will say that you shouldn t test protected functionality  I  however  find this very useful tool when adding new functionality    However  I don t use the keyword in directly in the class declarations  instead I use a nifty template-hack to achive this   template lt typename T gt  class FriendIdentity   public    typedef T me             A class to get access to protected stuff in unittests  Don t use    directly  use friendMe   instead      template lt class ToFriend  typename ParentClass gt  class Friender  public ParentClass   public    Friender        virtual  Friender      private     MSVC    GCC  ifdef  MSC VER   friend ToFriend   else   friend class FriendIdentity lt ToFriend gt   me   endif            Gives access to protected variables functions in unittests     Usage   lt code gt friendMe this  someprotectedobject  someProtectedMethod    lt  code gt      template lt typename Tester  typename ParentClass gt  Friender lt Tester  ParentClass gt   amp   friendMe Tester   me  ParentClass  amp  instance        return  Friender lt Tester  ParentClass gt   amp   instance       This enables me to do the following   friendMe this  someClassInstance  someProtectedFunction      Works on GCC and MSVC atleast

User · Answer

The tree example is a pretty good example    Having an object implemented in a few different class without having an inheritance relationship   Maybe you could also need it to have a constructor protected and force people to use your  friend  factory       Ok  Well frankly you can live without it

User · Answer

Firstly  IMO  don t listen to people who say friend is not useful  It IS useful  In many situations you will have objects with data or functionality that are not intended to be publicly available  This is particularly true of large codebases with many authors who may only be superficially familiar with different areas    There ARE alternatives to the friend specifier  but often they are cumbersome  cpp-level concrete classes masked typedefs  or not foolproof  comments or function name conventions    Onto the answer    The friend specifier allows the designated class access to protected data or functionality within the class making the friend statement  For example in the below code anyone may ask a child for their name  but only the mother and the child may change the name    You can take this simple example further by considering a more complex class such as a Window  Quite likely a Window will have many function data elements that should not be publicly accessible  but ARE needed by a related class such as a WindowManager   class Child     Mother class members can access the private parts of class Child  friend class Mother   public     string name  void     protected     void setName  string newName

User · Answer

Friend comes handy when you are building a container and you want to implement an iterator for that class

User · Answer

Another use  friend    virtual inheritance  can be used to avoid deriving from a class  aka   make a class underivable      1  2  From 2    class Fred    class FredBase    private     friend class Fred     FredBase             class Fred   private virtual FredBase    public

User · Answer

Friends are also useful for callbacks  You could implement callbacks as static methods  class MyFoo   private      static void callback void   data  void   clientData       void localCallback                 where callback calls localCallback internally  and the clientData has your instance in it  In my opinion    or     class MyFoo       friend void callback void   data  void   callData       void localCallback        What this allows is for the friend to be a defined purely in the cpp as a c-style function  and not clutter up the class   Similarly  a pattern I ve seen very often is to put all the really private members of a class into another class  which is declared in the header  defined in the cpp  and friended  This allows the coder to hide a lot of the complexity and internal working of the class from the user of the header   In the header   class MyFooPrivate  class MyFoo       friend class MyFooPrivate  public      MyFoo           Public stuff private      MyFooPrivate  private         Other private members as needed      In the cpp   class MyFooPrivate   public     MyFoo  owner        Your complexity here     MyFoo  MyFoo         this- gt  private- gt owner   this      It becomes easier to hide things that the downstream needn t see this way

User · Answer

You may use friendship when different classes  not inheriting one from the other  are using private or protected members of the other class      Typical use cases of friend functions are operations that are   conducted between two different classes accessing private or protected   members of both    from http   www cplusplus com doc tutorial inheritance     You can see this example where non-member method accesses the private members of a class  This method has to be declared in this very class as a friend of the class      friend functions  include  lt iostream gt  using namespace std   class Rectangle       int width  height    public      Rectangle          Rectangle  int x  int y    width x   height y         int area    return width   height       friend Rectangle duplicate  const Rectangle amp        Rectangle duplicate  const Rectangle amp  param      Rectangle res    res width   param width 2    res height   param height 2    return res     int main        Rectangle foo    Rectangle bar  2 3     foo   duplicate  bar     cout  lt  lt  foo area    lt  lt    n     return 0

User · Answer

The short answer would be  use friend when it actually improves encapsulation   Improving readability and usability  operators  lt  lt  and    are the canonical example  is also a good reason   As for examples of improving encapsulation  classes specifically designed to work with the internals of other classes  test classes come to mind  are good candidates

User · Answer

Probably I missed something from the answers above but another important concept in encapsulation is hiding of implementation  Reducing access to private data members  the implementation details of a class  allows much easier modification of the code later  If a friend directly accesses the private data  any changes to the implementation data fields  private data   break the code accessing that data  Using access methods mostly eliminates this  Fairly important I would think

User · Answer

I found handy place to use friend access  Unittest of private functions

User · Answer

This may not be an actual use case situation but may help to illustrate the use of friend between classes   The ClubHouse  class ClubHouse   public      friend class VIPMember     VIP Members Have Full Access To Class private      unsigned nonMembers       unsigned paidMembers       unsigned vipMembers       std  vector lt Member gt  members   public      ClubHouse     nonMembers  0   paidMembers  0   vipMembers 0          addMember  const Member amp  member           code          void updateMembership  unsigned memberID  Member  MembershipType type           code       Amenity getAmenity  unsigned memberID           code    protected      void joinVIPEvent  unsigned memberID           code          ClubHouse   The Members Class s  class Member   public      enum MemberShipType           NON MEMBER PAID EVENT       Single Event Paid  At Door          PAID MEMBERSHIP             Monthly - Yearly Subscription         VIP MEMBERSHIP              Highest Possible Membership           MemberShipType  protected      MemberShipType type       unsigned id       Amenity amenity   public      Member  unsigned id  MemberShipType type     id  id   type  type         virtual  Member         unsigned getId   const   return id         MemberShipType getType   const   return type         virtual void getAmenityFromClubHouse     0            class NonMember   public Member   public     explicit NonMember  unsigned id     Member  id  MemberShipType  NON MEMBER PAID EVENT             void getAmenityFromClubHouse   override          Amenity   ClubHouse  getAmenity  this- gt id               class PaidMember   public Member   public      explicit PaidMember  unsigned id     Member  id  MemberShipType  PAID MEMBERSHIP           void getAmenityFromClubHouse   override          Amenity   ClubHouse  getAmenity  this- gt id               class VIPMember   public Member   public      friend class ClubHouse  public      explicit VIPMember  unsigned id     Member  id  MemberShipType  VIP MEMBERSHIP           void getAmenityFromClubHouse   override          Amenity   ClubHouse  getAmenity  this- gt id                void attendVIPEvent             ClubHouse  joinVIPEvent  this- gt id               Amenities  class Amenity      If you look at the relationship of these classes here  the ClubHouse holds a variety of different types of memberships and membership access  The Members are all derived from a super or base class since they all share an ID and an enumerated type that are common and outside classes can access their IDs and Types through access functions that are found in the base class    However through this kind of hierarchy of the Members and its Derived classes and their relationship with the ClubHouse class the only one of the derived class s that has  special privileges  is the VIPMember class  The base class and the other 2 derived classes can not access the ClubHouse s  joinVIPEvent   method  yet the VIP Member class has that privilege as if it has complete access to that event    So with the VIPMember and the ClubHouse it is a two way street of access where the other Member Classes are limited

User · Answer

We had an interesting issue come up at a company I previously worked at where we used friend to decent affect   I worked in our framework department we created a basic engine level system over our custom OS   Internally we had a class structure            Game                 TwoPlayer  SinglePlayer   All of these classes were part of the framework and maintained by our team   The games produced by the company were built on top of this framework deriving from one of Games children   The issue was that Game had interfaces to various things that SinglePlayer and TwoPlayer needed access to but that we did not want expose outside of the framework classes   The solution was to make those interfaces private and allow TwoPlayer and SinglePlayer access to them via friendship     Truthfully this whole issue could have been resolved by a better implementation of our system but we were locked into what we had

User · Answer

With regards to operator lt  lt  and  operator   there is no good reason to make these operators friends   It is true that they should not be member functions  but they don t need to be friends  either   The best thing to do is create public print ostream amp   and read istream amp   functions   Then  write the operator lt  lt  and operator   in terms of those functions   This gives the added benefit of allowing you to make those functions virtual  which provides virtual serialization

User · Answer

The friend keyword has a number of good uses  Here are the two uses immediately visible to me   Friend Definition  Friend definition allows to define a function in class-scope  but the function will not be defined as a member function  but as a free function of the enclosing namespace  and won t be visible normally except for argument dependent lookup  That makes it especially useful for operator overloading   namespace utils       class f       private          typedef int int type          int type value       public             let s assume it doesn t only need  value  but some            internal stuff          friend f operator  f const amp  a  f const amp  b                   name resolution finds names in class-scope                  int type is visible here              return f a value   b value                      int getValue   const   return value              int main         utils  f a  b      std  cout  lt  lt   a   b  getValue       valid     Private CRTP Base Class  Sometimes  you find the need that a policy needs access to the derived class      possible policy used for flexible-class  template lt typename Derived gt  struct Policy       void doSomething                casting this to Derived  requires us to see that we are a             base-class of Derived          some type const amp  t   static cast lt Derived  gt  this - gt getSomething                 note  derived privately template lt template lt typename gt  class SomePolicy gt  struct FlexibleClass   private SomePolicy lt FlexibleClass gt           we derive privately  so the base-class wouldn t notice that           even though it s the base itself    so we need a friend declaration        to make the base a friend of us      friend class SomePolicy lt FlexibleClass gt        void doStuff                 calls doSomething of the policy          this- gt doSomething                  will return useful information     some type getSomething         You will find a non-contrived example for that in this answer  Another code using that is in this answer  The CRTP base casts its this pointer  to be able to access data-fields of the derived class using data-member-pointers

[c++] When should you use 'friend' in C++?

Examples related to c++

Examples related to oop

Examples related to encapsulation

Examples related to friend