C++ (Qt)
#ifndef ATOMICDATA_H
#define ATOMICDATA_H
 
#include <assert.h>
#include <cstdatomic>
 
template <class T>
class AtomicData
{
public:
    typedef atomic<int> AtomicInt;
    AtomicData()  : m_count_readers(0), m_state_write(-1) {}
 
    void setData(const T &data) {
        while (!acquireWrite(m_count_readers, m_state_write));
        m_data = data;
        releaseWrite(m_state_write);
    }
    T getData() const {
        while (!acquireRead(m_count_readers, m_state_write));
        T data = m_data;
        releaseRead(m_count_readers, m_state_write);
        return data;
    }
private:
    AtomicInt m_count_readers;
    AtomicInt m_state_write;
    T m_data;
 
    static bool acquireWrite(AtomicInt &readers, AtomicInt &state_write) {
 
        bool tmp = (++state_write == 0);
        state_write = 0;
 
        return (tmp && !readers);
    }
    //-------------------------------------------------------------------------
 
    static void releaseWrite(AtomicInt &state_write) {
        state_write = -1;
    }
    //-------------------------------------------------------------------------
 
    static bool acquireRead(AtomicInt &readers, AtomicInt &state_write) {
 
        if (!readers)
            readers = (state_write == -1);
        else
            readers++;
 
        return readers;
    }
    //-------------------------------------------------------------------------
 
    static void releaseRead(AtomicInt &readers, AtomicInt &state_write) {
        if (--readers == 0)
            state_write = -1;
    }
    //-------------------------------------------------------------------------
};
 
 
#endif // ATOMICDATA_H
 

C++ (Qt)
    static bool test_for_read(AtomicInt &key1, AtomicInt &key2) {
        bool res = (++key1 == 0);
        key2 = 0;
        key1 = -1;
        return res;
    }
};
 

C++ (Qt)
res1 = (++key == 0)
 

C++ (Qt)
#ifndef ATOMICDATA_H
#define ATOMICDATA_H
 
#include <cstdatomic>
 
template <class T>
class AtomicData
{
private:
    typedef atomic<int> AtomicInt;
    AtomicData()  : m_key1(-1), m_key2(-1) {}
    void setData(const T &data) {
        while (!test_for_write(m_key1, m_key2));
        // critical section
        m_data = data;
 
        m_key1 = -1;
        m_key2 = -1;
    }
    T getData() const {
        while (!test_for_read(m_key1, m_key2));
        // critical section
        T res = m_data;
        m_key1 = -1;
        m_key2 = -1;
        return res;
    }
private:
    AtomicInt m_key1;
    AtomicInt m_key2;
    T m_data;
 
    static bool test_for_write(AtomicInt &key1, AtomicInt &key2) {
        bool res1 = (++key1 == 0);
        bool res2 = (++key2 == 0);
        key1 = 0;
        key2 = 0;
        return (res1 && res2);
    }
 
    static bool test_for_read(AtomicInt &key1, AtomicInt &key2) {
        bool res = (++key1 == 0);
        key2 = 0;
        key1 = -1;
        return res;
    }
};
 

C++ (Qt)
#ifndef ATOMICDATA_H
#define ATOMICDATA_H
 
#include <asm/atomic.h>
 
template <class T>
class AtomicData
{
private:
    AtomicData() {
        m_key1 = ATOMIC_INIT(-1);
        m_key2 = ATOMIC_INIT(-1);
    }
    void setData(const T &data) {
        while (!test_for_write(&m_key1, &m_key2));
        // critical section
        m_data = data;
 
        atomic_set(&m_key1, -1);
        atomic_set(&m_key2, -1);
    }
    T getData() const {
        while (!test_for_read(&m_key1));
        // critical section
        T res = m_data;
        atomic_set(&m_key1, -1);
        atomic_set(&m_key2, -1);
        return res;
    }
private:
    atomic_t m_key1;
    atomic_t m_key2;
    T m_data;
 
    static bool test_for_write(atomic_t *key1, atomic_t *key2) {
        bool res1 = atomic_inc_and_test(key1);
        bool res2 = atomic_inc_and_test(key2);
        atomic_set(key1, 0);
        atomic_set(key2, 0);
        return (res1 && res2);
    }
 
    static bool test_for_read(atomic_t *key1) {
        bool res = atomic_inc_and_test(key1);
        atomic_set(&m_key2, 0);
        atomic_set(key1, -1);
        return res;
    }
};
 
 
#endif // ATOMICDATA_H
 

C++ (Qt)
NSimpleDataTypes()
        {
            _id = -1; _name = "";
            _constValue = false;
            _groupdatatypes = eNSimpleDataTypes;
        }
 
        NGroupDataTypes groupDataTypes() const {return _groupdatatypes;  }
 

C++ (Qt)
NSimpleDataTypes()
        {
            _id = -1; _name = "";
            _constValue = false;
        }
 
        NGroupDataTypes groupDataTypes() const {return eNSimpleDataTypes;  }
 

C++ (Qt)
virtual void setId(qint32 id) = 0;
        virtual QString name() const = 0;
        virtual void setName(QString name) = 0;
 

C++ (Qt)
virtual qint32 id() const = 0;
        virtual void setId(qint32 id) = 0;
        virtual QString name() const = 0;
        virtual void setName(QString name) = 0;
 

C++ (Qt)
class INDataTypes
    {
    public:
        virtual ~INDataTypes() { }
 
        qint32 id() const { return _id; } 
        void setId(qint32 id) { _id = id; }
        QString name() const { return _name; }
        void setName(QString name) { _name = name;}
 
        virtual NGroupDataTypes groupDataTypes() const = 0; // Оставить только эту фиртуальной
protected:
//если идентификатор равен -1, значит это либо временная переменная, либо константное значение
        qint32 _id;
        //константные или временные значения имен не имеют, только переменные.
        QString _name;
    };
 

C++ (Qt)
class NSimpleDataTypes : public INSimpleDataTypes
    {
    public:
        NSimpleDataTypes()
        {
            _id = -1; _name = "";
            _constValue = false;
            //_groupdatatypes = eNSimpleDataTypes; Нафига лишняя переменная?
        }
 
        NGroupDataTypes groupDataTypes() const {return eNSimpleDataTypes; /*_groupdatatypes; */ }
 
/* Это тоже лишнее */
        bool constValue() const {return _constValue;}
        void setConstValue(bool constValue) {_constValue = constValue;}               
    };
 

C++ (Qt)
shared_ptr<Data> ptr;
DataManager dataManager;
...
ptr = dataManager.data();
 

C++ (Qt)
while (m_flag++);  // <<-- Атомарна ли оно?
critical_section();
m_flag = 0;