Victor Bomberow

mov ecx, [data]
mov byte ptr[ecx], 5

class MySize
{
public:
    static const unsigned int size;
};

template <typename SizeT>
class MyValueT
{
protected:
    void* m_value;
public:
    MyValueT() {
        allocate_value();
    }
    void allocate_value() {
        m_value = malloc(SizeT::size);
        if (m_value == NULL)
            throw "Can't allocate MyValueT object";
        if (mlock(m_value, SizeT::size)) {
            free(m_value);
            throw "Can't lock MyValueT object";
        }
    }
    virtual ~MyValueT() {
        munlock(m_value, SizeT::size);
        free(m_value);
    }
    MyValueT(const MyValueT& src) {
        allocate_value();
        memcpy(m_value, src.m_value, SizeT::size);
    }
    operator int () const {
        int ret_val = 0;
        char* p = (char*) m_value;
        char* pv = (char*) &ret_val;
        for (unsigned int n = 0; n != SizeT::size && n != sizeof(int); ++n) {
            *pv = *p;
            p++;
            pv++;
        }
        return ret_val;
    }
    MyValueT& operator = (int val) {
        char* p = (char*) m_value;
        char* pv = (char*) &val;
        for (unsigned int n = 0; n != SizeT::size && n != sizeof(int); ++n) {
            *p = *pv;
            p++;
            pv++;
        }
        return *this;
    }
};

int main() 
{
    MyValueT<MySize> my_value;
    int n_value = 0x7FF5F4F3;
    my_value = n_value;
    cout << hex << n_value << " " << my_value << endl;
    return 0;
}