Are there any alternatives to using `friend` functions for accessing private data?

Question

Ryan McCombe · Accepted Answer

Yes, there are alternatives to using friend functions for accessing private data. These alternatives maintain encapsulation and often lead to more maintainable and flexible code.

Alternatives

Public Getter and Setter Methods: Use public methods to provide controlled access to private data.

1#include <iostream>
2
3class Example {
4 public:
5  int getValue() const { return value; }
6  void setValue(int val) { value = val; }
7
8 private:
9  int value{10};
10};
11
12int main() {
13  Example ex;
14  ex.setValue(20);
15  std::cout << "Value: " << ex.getValue();
16}

1Value: 20

Protected Members: Use protected members to allow access within the class hierarchy.

1#include <iostream>
2
3class Base {
4protected:
5  int value{10};
6};
7
8class Derived : public Base {
9public:
10  void showValue() {
11    std::cout << "Value: " << value;
12  }
13};
14
15int main() {
16  Derived d;
17  d.showValue();
18}

1Value: 10

Accessors within the Class: Create member functions that provide necessary access, keeping the internal logic within the class.

1#include <iostream>
2
3class Example {
4public:
5  void showValue() const {
6    std::cout << "Value: " << value;
7  }
8
9private:
10  int value{10};
11};
12
13int main() {
14  Example ex;
15  ex.showValue();
16}

1Value: 10

Dependency Injection: Pass dependencies to the class or function that needs to access private data.

1#include <iostream>
2
3class Dependency {
4 public:
5  void showValue(int val) {
6    std::cout << "Value: " << val;
7  }
8};
9
10class Example {
11 public:
12  Example(Dependency &dep) : dependency{dep} {}
13  void performAction() {
14    dependency.showValue(value);
15  }
16
17 private:
18  int value{10};
19  Dependency &dependency;
20};
21
22int main() {
23  Dependency dep;
24  Example ex(dep);
25  ex.performAction();
26}

1Value: 10

Design Patterns: Use design patterns like the Observer pattern, Strategy pattern, or Command pattern to manage interactions between classes without direct access to private members.

Conclusion

While friend functions offer a straightforward way to access private data, alternatives like public getters and setters, protected members, accessors within the class, dependency injection, and design patterns can provide more flexible and maintainable solutions.

These approaches help maintain encapsulation and promote better software design practices.

Friend Classes and Functions

Alternatives to Friend Functions

Alternatives

Conclusion

Friend Classes and Functions

Professional C++

Questions & Answers