// Voir la première ligne serialize() dans le main, en bas
// Compilé sous VS2012, ligne de commande minimale (cl.exe mem.cpp), pas d'optimisation

#include <iostream>

typedef unsigned char byte_t;

template <unsigned N, typename UnitType = byte_t>
    class memory_block {
        UnitType _b[N];

    public:
        UnitType*
        bytes () {
            return _b;
        }

        UnitType const*
        bytes () const {
            return _b;
        }

        const memory_block<N, UnitType>&
        assign (memory_block<N, UnitType> const& other) {
            for (unsigned i = 0; i < N; i++)
                bytes()[i] = other.bytes()[i];
            return *this;
        }
    };

template <typename Type>
    class scalar:
        public memory_block<sizeof(Type), byte_t> {

        Type&
        _get () {
            return *reinterpret_cast<Type*>(this);
        }

        template <typename... TArgs>
            void
            _construct (TArgs... args) {
                new (&_get()) Type(args...);
            }

        void
        _destruct () {
            _get().~Type();
        }

    public:
        template <typename... TArgs>
            scalar (TArgs... args) {
                _construct(args...);
            }

        ~scalar () {
            _destruct();
        }

        #define __nvfi_define_operator__(op) \
            template <typename T> \
                auto operator op (T value) -> decltype(scalar<Type>(_get() op value)) { \
                    return scalar<Type>(_get() op value); \
                }

        __nvfi_define_operator__(=);
        __nvfi_define_operator__(+=);
        __nvfi_define_operator__(-=);
        __nvfi_define_operator__(*=);
        __nvfi_define_operator__(/=);
        __nvfi_define_operator__(%=);
        __nvfi_define_operator__(+);
        __nvfi_define_operator__(-);
        __nvfi_define_operator__(*);
        __nvfi_define_operator__(/);
        __nvfi_define_operator__(%);

        operator Type () {
            return _get();
        }

        operator memory_block<sizeof(Type), byte_t>& () {
            return *this;
        }
    };

template <unsigned N, typename UnitType>
    void serialize(memory_block<N, UnitType> block) {
        for (unsigned i = 0; i < N; i++)
            std::cout << (i ? ":": "") << std::hex << (unsigned) block.bytes()[i];
    }

int main() {
    scalar<int> x = 0;
    std::cout << x << std::endl;
    memory_block<4> mb;
    mb.bytes()[0] = 0x2a;
    std::cout << std::endl;
    //serialize(x);          // A COMMENTER/DECOMMENTER
    std::cout << std::endl;
    x.assign(mb);
    std::cout << x << std::endl;
    serialize(x);
    return 0;
}