C++ destructor order of member with shared_ptr

If class A contains class B, then when A destruct, B's destructor will be called first, i.e., the reversed order of their nested relationship.

But what if A contains a shared_ptr of B, while B contains a raw pointer to A, how should we handle the destructor to make it safe?

Considering the following example:

#include <iostream>
#include <memory>
#include <unistd.h>

struct B;
struct A {
  int i = 1;
  std::shared_ptr<B> b;

  A() : b(std::make_shared<B>(this)) {}

  ~A() {
    b = nullptr;
    std::cout << "A destruct done" << std::endl;
  }
};

struct B {
  A *a;

  B(A *aa) : a(aa) {}

  ~B() {
    usleep(2000000);
    std::cout << "value in A: " << a->i << std::endl;
    std::cout << "B destruct done" << std::endl;
  }
};

int main() {
  std::cout << "Hello, World!" << std::endl;
  {
    A a;
  }
  std::cout << "done\n";
  return 0;
}

You can see in A's destructor, I explicitly set b to nullptr, which will trigger B's destructor immediately, and blocking until it finish. The output will be：

Hello, World!
value in A: 1
B destruct done
A destruct done
done

but if I comment out that line

  ~A() {
    // b = nullptr; // <---
    std::cout << "A destruct done" << std::endl;
  }

The output will be:

Hello, World!
A destruct done
value in A: 1
B destruct done
done

it seems that A's destructor finished without waiting B to destruct. But in this case, I expected segment fault, since when A already destructed, B tried to access the member of A, which is invalid. But why the program doesn't produce segment fault? Does it happen to be OK (i.e., undefined behavior)?

Also, when I change

 {
    A a;
 }

to

  A * a = new A();
  delete a;

the output is still the same, no segment fault.