Visibilité de mise à jour des membres C ++ dans une section critique lorsqu'elle n'est pas atomique

Je suis tombé sur le StackExchange de révision de code suivant et j'ai décidé de le lire pour m'entraîner . Dans le code, il y a ce qui suit:

Remarque: Je ne recherche pas de révision de code et il s'agit simplement d'un copier-coller du code à partir du lien afin que vous puissiez vous concentrer sur sur le problème en question sans que l'autre code n'interfère. Je ne suis pas intéressé par l'implémentation d'un 'pointeur intelligent', juste comprendre le modèle de mémoire:

#include <atomic>
#include <mutex>

struct ClassNameHere {
    int* rawObj;
    std::atomic<unsigned int> count;
    std::mutex mutex;

    // ...

    void deref()
    {
        std::scoped_lock lock{mutex};
        count--;
        if (count == 0)
            delete rawObj;
    }
};

Voir cela me fait immédiatement penser "et si deux threads entraient quand count == 1 et ni l'un ni l'autre ne voient les mises à jour l'un de l'autre? Les deux peuvent-ils finir par voir count comme zéro et une double suppression? Et est-il possible que deux threads provoquent count pour devenir -1 et ensuite la suppression ne se produit jamais?

Le mutex s'assurera qu'un thread entre dans la section critique, mais cela garantit-il que tous les threads seront correctement mis à jour? Que me dit le modèle de mémoire C ++ pour que je puisse dire que c'est une condition de concurrence ou non?

J'ai regardé le Page de référence du modèle de mémoire et std :: memory_order cppreference , mais cette dernière page semble traiter d'un paramètre pour atomic. Je n'ai pas trouvé la réponse que je cherchais ou je l'ai peut-être mal interprétée. Quelqu'un peut-il me dire si ce que j'ai dit est faux ou juste, et si ce code est sûr ou non?

Pour corriger le code s'il est cassé: p >

La bonne réponse pour cela est-elle de transformer le compte en un membre atomique? Ou est-ce que cela fonctionne et après avoir libéré le verrou sur le mutex, tous les threads voient la valeur?

Je suis également curieux de savoir si cela serait considéré comme la bonne réponse:

Remarque: je ne recherche pas de révision de code et j'essaie de voir si ce type de solution résoudrait le problème concernant le modèle de mémoire C ++.

// Copied from the link provided (all inside a class)

unsigned int count;
mutex m_Mutx;

void deref()
{
    m_Mutx.lock();
    count--;
    m_Mutx.unlock();
    if (count == 0)
    {
        delete rawObj;
        count = 0;
    }
}