friend AND inline method, what’s the point ?

by 
friend inline bool operator==(MonitorObjectString& lhs, MonitorObjectString& rhs) { 
    return(lhs.fVal==rhs.fVal); 
}

is sometimes called friend definition, because it is a friend declaration that also defines the function. It will define the function as a non-member function of the namespace surrounding the class it appears in. Actually, the inline there is redundant: It’s implicitly declared inline if it’s a friend definition. Some pros and cons of it:

  • It makes the operator not visible to normal lookup. The only way you can call it is using argument dependent look-up. This will keep the namespace free of lots of operator declarations visible normally. Note that this will also disable the ability of calling it using implicit conversions to MonitorObjectString (because if both argument types do not match at the time of looking for candidates to be called, argument dependent look-up won’t find the function).
  • The lookup for names starts in the scope of the class the friend definition appears in. This means that no long type-names or other names need to be written out. Just refer them as you would in a normal member function of the class.
  • As it is a friend, the function sees the internals of MonitorObjectString. But that’s neither good nor bad. It depends on the situation. For example if there are functions getFVal() making the function friend is pretty pointless. Could use getFVal as-well then.

I used to like this friend definition style of operators, because they have direct access to class members, and appear within the class definition – so I could have “everything with one sight”. Recently, however, I came to the conclusion that it’s not always a good idea. If you can (and you should) implement the operator purely using public member functions of the class, you should make it a non-friend (and non-member) operator, defined in the same namespace of the class. It makes sure that if you change some implementation – but keep the interface of the class the same – the operator will still work and you have less cascading changes, because you know it can’t access implementation details.

However, I prefer this style over writing member operators, because operator functions at namespace scope have the added features of being symmetric with their arguments: They don’t treat the left side special, because both sides are just normal arguments and not object arguments that are bound to *this. If either the left or the right side is of the type of your class, the other side can be implicitly converted – regardless of whether it’s left or right. For functions that are also defined without the friend definition syntax (traditionally, at namespace scope), you will have the feature of selectively including headers that make those operators available or not.

More Related Contents:

  1. What’s the scope of inline friend functions?
  2. Is there still a use for inline? [duplicate]
  3. When should I write the keyword ‘inline’ for a function/method?
  4. overloading friend operator
  5. Inline functions vs Preprocessor macros
  6. When to use inline function and when not to use it?
  7. Why does this C++ snippet compile (non-void function does not return a value) [duplicate]
  8. Can we increase the re-usability of this key-oriented access-protection pattern?
  9. How to declare a templated struct/class as a friend?
  10. Is this key-oriented access-protection pattern a known idiom?
  11. Inline function linkage
  12. Are inner classes in C++ automatically friends?
  13. C++ inline member function in .cpp file
  14. C++ inlining class methods causes undefined reference
  15. declare template friend function of template class
  16. Function declaration inside or outside the class
  17. Friend scope in C++
  18. How will i know whether inline function is actually replaced at the place where it is called or not?
  19. clean C++ granular friend equivalent? (Answer: Attorney-Client Idiom)
  20. Is “inline” implicit in C++ member functions defined in class definition
  21. ‘friend’ functions and
  22. How Can I Pass a Member Function to a Function Pointer?
  23. Overload operators as member function or non-member (friend) function?
  24. Why does a C++ friend class need a forward declaration only in other namespaces?
  25. Is it legal/well-defined C++ to call a non-static method that doesn’t access members through a null pointer?
  26. a class-key must be declared when declaring a friend
  27. Template definitions outside class body
  28. How to name this key-oriented access-protection pattern?
  29. Specify a class member function as a friend of another class?
  30. friend declaration declares a non-template function [duplicate]

Leave a Comment