class C_B;

////////////////////////////
////       C_A          ////
////////////////////////////
class C_A
{
    C_B* m_pB;

    int  m_x;
public:
    //------------------------------------------
    void set_pB(C_B* pB){m_pB = pB;}
    //------------------------------------------
    void set_x(int x)   {m_x = x;}
    //------------------------------------------
    void foo_A(void)const;// несмотря на const, вызов этой функции может изменить значение поля m_x
    //------------------------------------------
};
////////////////////////////

////////////////////////////
////       C_B          ////
////////////////////////////
class C_B
{
    C_A* m_pA;
public:
    //------------------------------------------
    C_B(C_A* pA):m_pA(pA){}
    //------------------------------------------
    void foo_B(void){ m_pA->set_x(10);}
    //------------------------------------------
};
////////////////////////////

//------------------------------------------
void C_A::foo_A(void)const
{
    m_pB->foo_B();
}
//------------------------------------------



void main(void) 
{
    C_A A;
    C_B B(&A);

    A.set_pB(&B);

    A.set_x(0);
    A.foo_A();
}

class
t_Something
{
  protected: t_Something * m_p_non_const;
  protected: int           m_x = 0;
    
  public:
  t_Something(void)
  :  m_p_non_const(this)
  {
    // do nothing;
  }
    
  public: void
  Set_X(int const x) const
  {
    m_p_non_const->m_x = x;
  }
};

int
main(void)
{
  t_Something const something;
  something.Set_X(42);
}

struct X 
{ 
    X * next; 
    void f() const { next->next = nullptr; }
};

void something(X * x);

int main()
{
    X x;
    something(&x); // Какими будут поля структуры X после выхода из метода?
    x.f(); // Как понять, есть нарушение или нет?
    return 0;
}

#ifdef UB
    void something(X * x)
    {
        x->next = x;
    }
#else
    void something(X * x)
    {
        x->next = new X();
    }
#endif

T & get();
T const & get() const;

M>struct X 
M>{ 
M>    X * next; 
M>    void f() const { next->next = nullptr; }
M>};

M>void something(X * x);

M>int main()
M>{
M>    X x;
M>    something(&x); // Какими будут поля структуры X после выхода из метода?
M>    x.f(); // Как понять, есть нарушение или нет?
M>    return 0;
M>}

M>#ifdef UB
M>    void something(X * x)
M>    {
        x->>next = x;
M>    }
M>#else
M>    void something(X * x)
M>    {
        x->>next = new X();
M>    }
M>#endif

M>

void f() const { next->next = nullptr; }

void f() class_const { next->next = nullptr; }

void f() class_const { (const X*)next->next = nullptr; }

BFE>>В системе автопилота самолета используется паттерн сигнал-слот? Не делайте так.

void f()
{
   fun1();
   fun2();
   fun3();
   fun4();
}

void f()
{
   ...
}

    void C_B::foo_B(void){ m_pA->set_x(10);}

    void C_B::foo_B(void){ delete m_pA;}

void foo_A(void)class_const;

void C_A::foo_A(void)const
{
    m_pB->foo_B();
}

class X;

void foo(X* x) {
  bar(x);
  #pragma TURN CONST ON
  buz(x); // вот здесь - и далее вглубь - константность навешана на всё
  #pragma TURN CONST OFF
  bar(x);
  buz(x);
}

struct Mutable { Immutable& turn_const_on() const; };
struct Immutable : Mutable {};

template<class Traits>
void foo(Traits& t, X* x) {
  bar(t, x);
  buz(t.turn_const_on(), x);
  buz(t, x); // константность включится по требованию
}

void bar(Mutable& t, X* x);
void buz(Immutable& t, X const* x);

class X {
#ifdef _DEBUG
  bool is_mutable = true;
  thread_local static bool all_mutable = true;

  void turn_mutable(bool m) { is_mutable = m; }
  static void turn_all_mutable(bool m) { all_mutable = m; }
  void assert_mutable() { assert(is_mutable && all_mutable); }
#else
  void turn_mutable(bool m) {}
  static void turn_all_mutable(bool m) {}
  void assert_mutable() {}
#endif
  .....
};

void foo(X* x) {
  bar(x);
  X::turn_all_mutable(false);
  buz(x);
  X::turn_all_mutable(true);
  bar(x);
  buz(x);
}

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 { ..... }