如果你愿意做一些依赖注入，或者愿意做一个类到抽象基类的显式转换以获得对私有成员函数的访问，那么有一种方法可以在每个函数的基础上对访问进行建模。
我曾经在一个类需要多个“朋友”的情况下使用过这些方法，但是这些朋友应该对不同的成员函数有不同的访问权限。做正确的事情仍然比较容易，但获得“私人”访问并非不可能。这是一个很好的折衷方案，可以检查代码中谁可以访问什么（因此也可以在代码审查中检测误用）。
现场演示：https://onlinegdb.com/TFVGm-HVW
首先，我们创建两个接口，用于每个类访问class A：

#include <iostream>
class interface_for_class_b
{
public:
    virtual void method_for_class_b() = 0;
};
class interface_for_class_c
{
public:
    virtual void method_for_class_c() = 0;
};

然后，创建一个class A，它继承了两者，但保留了private的实现。这对所有人隐藏了成员函数。

class A :
    public interface_for_class_b,
    public interface_for_class_c
{
public:
    void some_public_method()
    {
        std::cout << "A::some_public_method()\n";
    }
private:
    void method_for_class_b() override 
    {
        std::cout << "A::method_for_class_b()\n";
    };
    void method_for_class_c() override 
    {
        std::cout << "A::method_for_class_c()\n";
    };
};

然后，使用依赖注入：

• class B接收interface_for_class_b
• class C接收interface_for_class_c

class B
{
public:
    explicit B(interface_for_class_b& a) :
        m_interface_to_a{ &a } { }
    void some_method()
    {
        std::cout << "B::some_method()\n";
        // B can access "private" function through the explicit interface.
        m_interface_to_a->method_for_class_b();
    }
private:
    interface_for_class_b* m_interface_to_a;
};
class C
{
public:
    explicit C(interface_for_class_c& c) :
        m_interface_to_a{ &c } { }
    void some_method()
    {
        std::cout << "C::some_method();\n";
        m_interface_to_a->method_for_class_c();
    }
    
private:
    interface_for_class_c* m_interface_to_a;
};

下面是我们如何使用这些类：

int main()
{
    A a;
    B b{ a }; // inject dependency to give b access to "private"functions
    C c{ a };
    a.some_public_method();
    // a.method_for_class_b();
    // is not accessible, it is private
    b.some_method();
    c.some_method();
    // if you don't want to or cannot do dependency injection
    // there is an alternative way to get access to the specific methods
    // this explicit step says you want detailed access to class a
    // so it is also self-documenting.
    interface_for_class_b& itf{ a };
    itf.method_for_class_b();
    return 0;
}