Using Pointers to Non-Public Member Functions

Yes, it is possible to use member function pointers with non-public (protected or private) member functions in C++. However, there are some important considerations and limitations to keep in mind. Let's explore this topic in detail:

In C++, you can create pointers to private and protected member functions. The key thing to remember is that the accessibility of a member function doesn't affect your ability to take its address. However, it does affect where you can use that pointer.

Let's start with a simple class that has private and protected methods:

1#include <iostream>
2
3class MyClass {
4 private:
5  void privateMethod() {
6    std::cout << "Private method\n";
7  }
8
9 protected:
10  void protectedMethod() {
11    std::cout << "Protected method\n";
12  }
13
14 public:
15  void publicMethod() {
16    std::cout << "Public method\n";
17  }
18
19  // Function to demonstrate usage
20  void demo();
21};

You can create pointers to these methods like this:

1void (MyClass::*privatePtr)() = &MyClass::privateMethod;
2void (MyClass::*protectedPtr)() = &MyClass::protectedMethod;
3void (MyClass::*publicPtr)() = &MyClass::publicMethod;

You can only create these pointers in contexts where you would normally be allowed to access the functions.

Here's how you might use these pointers inside a member function of MyClass:

1#include <iostream>
2
MyClass Class|Show
3class MyClass {/*...*/};
23
24void MyClass::demo() {
25  void (MyClass::*privatePtr)() =
26    &MyClass::privateMethod;
27  void (MyClass::*protectedPtr)() =
28    &MyClass::protectedMethod;
29  void (MyClass::*publicPtr)() =
30    &MyClass::publicMethod;
31
32  MyClass obj;
33
34  (obj.*privatePtr)();
35  (obj.*protectedPtr)();
36  (obj.*publicPtr)();
37}
38
39int main() {
40  MyClass Example;
41  Example.demo();
42}

1Private method
2Protected method
3Public method

You cannot create pointers to private or protected methods outside of the class or its derived classes. For example, this would not compile:

1int main() {
2  MyClass obj;
3  
4  // Error! Cannot access private member
5  void (MyClass::*ptr)() =
6    &MyClass::privateMethod;
7}

1error: 'MyClass::privateMethod': cannot access private member declared in class 'MyClass'

Friend classes and functions can use pointers to private and protected members, just as they can access these members directly:

1#include <iostream>
2
3class MyClass {
4  void privateMethod() {
5    std::cout << "Private method\n";
6  }
7  friend class FunctionCaller;
8};
9
10class FunctionCaller {
11 public:
12  void usePrivateMethod(MyClass& obj) {
13    // OK, FunctionCaller is a friend of MyClass
14    void (MyClass::*ptr)() =
15      &MyClass::privateMethod;
16    (obj.*ptr)();
17  }
18};
19
20int main() {
21  MyClass Object;
22  FunctionCaller Friend;
23  Friend.usePrivateMethod(Object);
24}

1Private method

1. Testing: Pointers to non-public members can be useful in unit testing, allowing test code to access and verify the behavior of private methods.
2. Callbacks: You might use pointers to protected methods as callbacks in a base class, allowing derived classes to override the behavior.
3. Design Patterns: Some design patterns, like the Template Method pattern, might use pointers to protected methods to customize behavior in derived classes.
4. Caution: While it's possible to use pointers to non-public members, it's generally best to respect the encapsulation principles of OOP. If you find yourself frequently needing to access private members, consider if your class design could be improved.

Remember, the ability to create pointers to non-public members doesn't bypass C++'s access control mechanisms. It simply allows you to store and pass around the address of these functions in a type-safe way.

The actual invocation of these functions through the pointers is still subject to the normal access control rules.