How Non-Member Functions Improve Encapsulation

by

Question 1

In this case, following Meyers’s algorithm will give you member functions:

  • Do they need to be virtual? No.
  • Are they operator<< or operator>>? No.
  • Do they need type conversions? No.
  • Can they be implemented in terms of the public interface? No.
  • So make them members.

His advice is to only make them friends when they really need to be; to favour non-member non-friends over members over friends.

Question 2

The SetXXXX functions need to access the internal (private) representation of the class, so they can’t be non-member non-friends; so, Meyers argues, they should be members rather than friends.

The encapsulation comes about by hiding the details of how the class is implemented; you define a public interface separately from a private implementation. If you then invent a better implementation, you can change it without changing the public interface, and any code using the class will continue to work. So Meyers’s “number of functions which might be broken” counts the member and friend functions (which we can easily track down by looking at the class definition), but not any non-member non-friend functions using the class through its public interface.

Question 3

This has been answered.

The important points to take away from Meyers’s advice are:

  • Design classes to have clean, stable public interfaces separate from their private implementation;
  • Only make functions members or friends when they really need to access the implementation;
  • Only make functions friends when they can’t be members.

More Related Contents:

  1. Declaring lambda with int type not working [closed]
  2. Matrix Printing using Pointers [closed]
  3. Function with same name but different signature in derived class
  4. Using generic std::function objects with member functions in one class
  5. Where should I prefer pass-by-reference or pass-by-value?
  6. Top-level const doesn’t influence a function signature
  7. Is there a way to pass auto as an argument in C++?
  8. Difference between [square brackets] and *asterisk
  9. Using multiple .cpp files in c++ program?
  10. How to call a function by its name (std::string) in C++?
  11. Is it a good practice to define C++ functions inside header files? [duplicate]
  12. Should I pass an std::function by const-reference?
  13. C++ inherit from multiple base classes with the same virtual function name
  14. Is there still a use for inline? [duplicate]
  15. When is a function try block useful?
  16. Explanation of function pointers
  17. Function with same name but different signature in derived class not found
  18. What happens when a function that returns an object ends without a return statement
  19. array of pointers as function parameter
  20. Why do two functions have the same address?
  21. Function returning array but main showing garbage [duplicate]
  22. How does the friend keyword (Class/Function) break encapsulation in C++?
  23. How to properly use system() to execute a command in C++?
  24. Template type deduction in C++ for Class vs Function?
  25. What does *& mean in a function parameter
  26. Boost.Python: Wrap functions to release the GIL
  27. non-const pointer argument to a const double pointer parameter
  28. Can I get polymorphic behavior without using virtual functions?
  29. order of evaluation of function parameters
  30. Differences of using “const cv::Mat &”, “cv::Mat &”, “cv::Mat” or “const cv::Mat” as function parameters?

Leave a Comment