public class MyClass {
    public static void main(String args[]) {
        var x = new Helper();
        var y = new Helper();

        x.add(2);
        x.mul(10);
        
        y.add(3);
        y.mul(5);

      System.out.println("Sum of x+y = " + (x.current() + y.current()) );
    }
}

class Helper {
    private int x = 0;
    public void add(int d) {
        x += d;
    }
    public void mul(int d) {
        x *= d;
    }
    public int current() { return x; }
}

class A;
class B;
class OnlyA{ friend class A; private: OnlyA(){} };

class A {
  friend void modify_A(A &, B &, OnlyA);
public:
  void f(B & consumer);
private: int m_iA{0};  
};

class B {
  friend void modify_A(A &, B &, OnlyA);

public:
private: int m_iB{0};  
};

void A::f(B & b) {
  modify_A(*this, b, OnlyA{});
}

void modify_A(A & a, B & b, OnlyA) {
  // Тут есть доступ и к потрохам A, и к потрохам B.
  a.m_iA++;
  b.m_iB++;
}

int main()
{
    A a;
    B b;
    a.f(b);
  //modify_A(a, b, OnlyA{});

  return 0;
}

ЕМ>Тот, кто не имеет экземпляра класса или указателя/ссылки на него, не сможет ничего сделать данными класса. Вытекает ли из этого, что private не имеет смысла?

class B;

class A {
  friend void B::f(int a) const;
  ...
};

void g(B & b) // Это допустимо и без полного определения B.
{
  b.f(0); // Ведь мы знаем про наличие f(int) в B.
  ...
}

class Demo {
  void f() {
    ...
    this->g();
  }
  void g() {
    ...
  }
  ...
};

class Demo {
  void f(); // Никакого inline в определении класса.
  void g(); // Никакого inline в определении класса.
  ...
};
void Demo::f() {
  this->g(); // Теперь OK, т.к. определение класса было выше.
}
void Demo::g() {
  ...
}

Я так понял, что решается следующая задача:

— нужно минимизировать объем кода, который имеет доступ к потрохам класса A (т.е. до одной функции/метода);
— сделать это нужно в условиях, когда перед определением класса A нельзя сделать определение класса B (которому и нужен доступ к потрохам B).

Верно.

#include <utility>
#include <iostream>

class Demo {
    int m_a;

    friend void swap(Demo & a, Demo & b) noexcept;

    friend std::ostream & operator<<(std::ostream & to, const Demo & v);

public:
    Demo() : m_a{42} {}

    void change(int v) { m_a = v; }
};

int main() {
    Demo a, b;
    std::cout << a << b << std::endl;
    a.change(50);
    b.change(60);
    std::cout << a << b << std::endl;
    swap(a, b);
    std::cout << a << b << std::endl;
}

void swap(Demo & a, Demo & b) noexcept {
    using std::swap;
    swap(a.m_a, b.m_a);
}

std::ostream & operator<<(std::ostream & to, const Demo & v) {
    return (to << v.m_a);
}

struct nest
{
private:
  struct hidden {};
};

int main()
{
  nest::hidden v; // error C2248: 'nest::hidden': cannot access private struct declared in class 'nest'
  return 0;
}

struct nest
{
private:
  struct hidden_1;
  struct hidden_2;
  struct hidden_3;

public:
  static void fn_test();
};

struct nest::hidden_1 {};
struct nest::hidden_2 { hidden_1 data; };
struct nest::hidden_3 {};

void nest::fn_test()
{
  hidden_2 obrabotchik;
}

int main()
{
  nest::fn_test();
  return 0;
}

S>>public read_only protected full_access:
S>>

public read_only protected read_only:

Есть у нас класс environment_t, который дает пользователю доступ к ряду публичных методов. Но внутри библиотеки нужно уметь обращаться и к закрытой части функциональности этого класса. Причем из разных мест библиотеки.

Вариант сделать все эти места (т.е. внутренние классы и функции, да и не только внутренние, некоторые публичные классы/функции в своей реализации так же должны обращаться к закрытой части environment_t) друзьями environment_t -- это прямой путь в никуда (иметь вот такие списки не есть хорошо в долгосрочной перспективе).

Поэтому проще объявить для environment_t другом отдельный внутренний класс internal_env_iface_t, который живет в специальном внутреннем пространстве имен и не предназначен для прямого использования конечным пользователем.

Конечно, в C++ нет средств полностью ограничить доступ к internal_env_iface_t.