void g()
{
   f();
}

void f()
{
  static bool b = false; // если f() - член класса, то b может/должна быть нестатическим членом класса
  if ( b )
  {
    // cycle
    return;
  } 
  b = true; // RAII must be here
  g(); 
  b = false;
}

class X {
  X* xz_;
public:
  // стандартный приём: делаем глубокую константность
  X* xz() { return xz_; }
  X const* xz() const { return xz_; }
};

template<class T> class deep_constness_ptr {
  T* p_;
public:
  T* get();
  T const* get() const;
  // и так далее, весь обвес класса-указателя
};

class X1 {
public:
  deep_constness_ptr<X1> xz_;
};

// и теперь самое страшное!

//namespace GodNamespace // было
struct GodContext { // стало
  static X* x();
  static X const* x() const; // дублируем все функции примитивного доступа

  // либо заменяем обычные указатели на глубокие
  deep_constness_ptr<X> y;

  // и переписываем сложные функции - добавляя нужную константность
  void bar();
  void buz() const;

  // на самый крайний случай, оставим себе право на шаблон
  template<class GodContextWithOrWithoutConst>
  static void foo(GodContextWithOrWithoutConst* myself) {
    myself->x();
    myself->y;
    myself->foo();
    myself->bar(); // где-то мы и по пальцам получим!
  }
};

// не конкретизирую недра
struct Session;
bool allowed_to_set_x(Session);
bool allowed_to_set_y(Session);

class CA {
  void set_x(Session s, int x) { assert(allowed_to_set_x(s); m_x = x; }

  void foo() { m_pB->foo(make_session_with_all_permissions()); }
  void bar() const { m_pB->bar(make_session_without_permissions()); }

  // вид сессии можно и из константности выводить - ИНОГДА
  Session make_typical_session()       { return make_session_with_all_permissions(); }
  Session make_typical_session() const { return make_session_without_permissions(); }

  ...
};

class CB {
  void foo(Session s) { m_pA->set_x(s, 123); }
  void bar(Session s) { m_pA->set_x(s, 456); } // если оно вызывается ТОЛЬКО из CA::bar()const, получим по пальцам
};

CA::foo() { m_pB->foo(this); }
CA::bar() const { m_pB->bar(); }

CB::foo(CA* pA) { assert(pA == m_pA); pA->set_x(123); }
CB::bar() { m_pB->get_x(); }

class CA {
  class Permitted {
    private: Permitted() {} // чтоб неповадно было
    friend class CA;
  };

  void set_x(int x);
  void set_y(int y);

  CA* get_mutable_myself(Permitted) const { return const_cast<CA*>(this); }

  void foo() { m_pA->foo(Permitted()); } // захотели и разрешили
  void bar() const { m_pB->bar(); }
};

class CB {
  CA const* m_pA;

  void foo(CA::Permitted p) {
    CA* pA = m_pA->get_mutable_myself(p); // реализовали право
    pA->set_x(123);
    pA->set_y(456);
  };

  void bar() {
    // никак не взять неконстантный pA.
  }
};

1. не требует вообще никакой доп. памяти и структур (кроме тех что уде наверняка есть типа parent child)
   
2. гибкий и мощный — позволяет разные event handling & delivering policy использовать.
   
3. принципиально свободен от проблемы циклов (loops).

К>// не конкретизирую недра
К>struct Session;
К>bool allowed_to_set_x(Session);
К>bool allowed_to_set_y(Session);

К>class CA {
К>  void set_x(Session s, int x) { assert(allowed_to_set_x(s); m_x = x; }

К>  void foo() { m_pB->foo(make_session_with_all_permissions()); }
К>  void bar() const { m_pB->bar(make_session_without_permissions()); }

К>  // вид сессии можно и из константности выводить - ИНОГДА
К>  Session make_typical_session()       { return make_session_with_all_permissions(); }
К>  Session make_typical_session() const { return make_session_without_permissions(); }

К>  ...
К>};

К>class CB {
К>  void foo(Session s) { m_pA->set_x(s, 123); }
К>  void bar(Session s) { m_pA->set_x(s, 456); } // если оно вызывается ТОЛЬКО из CA::bar()const, получим по пальцам
К>};
К>

class CB {
   C_A* m_pA;
  ...
  void foo(Session s) {  m_pA->set_x(s, 123); }
  //void bar(Session s) { m_pA->set_x(s, 456); } // если оно вызывается ТОЛЬКО из CA::bar()const, получим по пальцам
  void bar(Session s) 
  {
       const Session SessionWithAllPermissions = m_pA->make_typical_session(); // поскольку m_pA есть неконтсантный указатель C_A*, то все ок - я получу сессию со всеми разрешениями на модификацию
       m_pA->set_x(SessionWithAllPermissions, 456); // опять же, поскольку сессия все разрешает, то могу модифицировать 
  } 
};

const CA* pA;
....
const_cast<CA*>(pA)->set_x(123); // эй компилятор, почему ты не дал мне здесь по пальцам?!

if(Great_Unresolved_Problem_Is_True()) { ..... } else { ..... }