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;
}

#include <iostream>

template <typename T>
struct restricted
{
  friend void T::go(const restricted &) const;
private:
  int value{55};
};

struct agent
{
  template <typename T>
  void go(const T & r) const
  {
    std::cout << r.value << '\n';
  }
};

int main()
{
  restricted<agent> v;
  agent a;
  a.go(v);
  return 0;
}

55

struct S {
    void foo(int);
};

struct B {
      virtual void foo(int);
};

struct U {
    virtual void bar(int);
    virtual void foo(int);
};

struct V {
    virtual void foo(int);
    virtual void bar(int);
};

U* u = ...;
u->foo(1);

S>>public read_only protected full_access:
S>>

public read_only protected read_only:

ЕМ>Вы, когда Вас заедает на каком-то принципиальном вопросе, говорите не меньше.

struct Demo { ... };

void update(Demo & self, ...) {...}
void print(Demo & self, ...) {...}
...
Demo d;
d.update(...);

class Demo {
  void method() {
    std::cout << "Hello, stupid!" << std::endl;
  }
  ...
};

class Demo {
  void method();
  ...
};

void Demo::method() {
  std::cout << "Hello, stupid!" << std::endl;
}

class B; // Будет определен хз где, возможно, в закрытой части библиотеки.

class A { // А вот определение для A делается прямо здесь.
  // Вот какую штуку хочет ТС:
  friend void B::some_method(A &); // Музыченко готов присягнуть компилятору кровью
                                   // что в классе B будет some_method.
  ...
};

struct A
{
    friend void foo();
};

int main()
{
    foo(); // error: 'foo' was not declared in this scope
}

namespace ns
{

void foo();
    
} // namespace ns

struct A
{
    friend void ns::foo(); // Ok
    friend void ns::bar(); // error: 'void ns::bar()' should have been declared inside 'ns'
};

namespace ns
{

void foo();
    
} // namespace ns

struct A
{
    friend void ns::foo(); // Ok
    friend void ns::bar(); // error: 'void ns::bar()' should have been declared inside 'ns'
};

Язык допускает предварительное объявление (forward declaration) дружественной (friend) обычной (non-member) функции

#include <type_traits>
#include <iostream>

  template <typename Type, typename ... U>
  concept c_any_of = (std::is_same_v<Type, U> || ...);

template <typename ... T>
struct restricted
{
  template <c_any_of<T ...> U>
  friend void U::go(const restricted &) const;
private:
  int value{55};
};

struct agent_A
{
  template <typename T>
  void go(const T & r) const
  {
    std::cout << "A: " << r.value << '\n'; // fail
  }
};

struct agent_B
{
  template <typename T>
  void go(const T & r) const
  {
    std::cout << "B: " << r.value << '\n';
  }
};

int main()
{
  restricted<agent_A, agent_B> v;
  agent_A a;
  agent_B b;
  a.go(v);
  b.go(v);
  return 0;
}

#include <type_traits>
#include <iostream>

struct t_file;
struct t_console;
struct restrict;

template <typename Type>
struct io_actions
{
  using pointer = Type *;

  // data
  pointer self;

  // methods
  void read(restrict & p);
  void write(restrict & p);

  // hint
  io_actions * operator -> () { return this; }
};

struct restrict
{
  friend void io_actions<t_console>::write(restrict &);
  friend void io_actions<t_console>::read(restrict &);
  friend void io_actions<t_file>::write(restrict &);
  friend void io_actions<t_file>::read(restrict &);
private:
  int value{55};
};

struct t_console
{
  using trait = io_actions<t_console>;

  // data
  std::istream * in{& std::cin};
  std::ostream * out{& std::cout};

  trait operator -> () { return {this}; }
};

template <> void t_console::trait::read(restrict & p) { (*self->in) >> p.value; }
template <> void t_console::trait::write(restrict & p) { (*self->out) << p.value; }

int main()
{
  restrict v;
  t_console c;
  c->write(v);
  return 0;
}

template <> void t_file::trait::read(restrict & p) { /* ... */ }
template <> void t_file::trait::write(restrict & p) { /* ... */ }

class A;
class B;

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

  void f(B & consumer);
};

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

public:
  ...
  void consume(A & a) {
    modify_A(a, *this);
  }
};

void A::f(B & consumer) {
  consumer.consume(*this);
}

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

public read_only protected full_access:

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; }
}

ЕМ>Тот, кто не имеет экземпляра класса или указателя/ссылки на него, не сможет ничего сделать данными класса. Вытекает ли из этого, что 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;
}

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

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

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

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

class A;
class B;

class B
{
  public: void AccessToA(A& a);
};

class A 
{
  friend void B::AccessToA(A& a);
  private: int m_iA{0};  
};

void B::AccessToA(A& a)
{
    std::cout << a.m_iA << std::endl;
}

int main()
{
    A a;
    B b;
    b.AccessToA(a);
    return 0;
}

class A;
class B;

class A 
{
  friend void AccessToA(B* b, A& a);
  private: int m_iA{0};  
};


class B
{
  friend void AccessToA(B* b, A& a);
};

void AccessToA(B*, A& a)
{
    std::cout << a.m_iA << std::endl;
}

int main()
{
    A a;
    B b;
    AccessToA(&b, a);
    return 0;
}

S>class B; // Будет определен хз где, возможно, в закрытой части библиотеки.

S>class A { // А вот определение для A делается прямо здесь.
S>  // Вот какую штуку хочет ТС:
S>  friend void B::some_method(A &); // Музыченко готов присягнуть компилятору кровью
S>                                   // что в классе B будет some_method.
S>  ...
S>};
S>

class A { A _a; };

// unit1.h
class B; // Будет определен хз где, возможно, в закрытой части библиотеки.

class A {
  int _value{3};
  friend void B::some_method(A &); // вот это запрещено природой незавершённого типа С++ и всё
};

// unit2.h
class A; // Будет определен хз где, возможно, в закрытой части библиотеки.

class B {
  void some_method(A &);
};

// unit2.cpp
#include "unit1.h"

void B::some_method(A & a) {
  a._value; // compiler checks access right for A privates
}