bits.cpp

#include <iostream>
#include <cstdint>
using namespace std;

template <typename T = uint16_t> // szablon, domyślnie uint16_t
class bitx {
    private:
        volatile T _reg;
        uint16_t _size;

    public:
        bitx(T reg) : _reg(reg), _size(sizeof(T) << 3){}
        bitx() : bitx(0){}

        bitx & operator = (T reg) noexcept{
            _reg = reg;
            return *this;
        }

        operator T() const noexcept{
            return _reg;
        }

        // błąd (-1), wynik (0 lub 1)
        inline int bit_get(uint16_t pos) const{
            return (pos < _size ? ((_reg >> pos) & 0x1) : -1);
        }

        // błąd (false), sukces (true)
        inline bool bit_set(uint16_t pos, bool stat){
            return (pos < _size) ? (stat ? (_reg |= (1 << pos)) : (_reg &= ~(1 << pos)), true) : false;
        }

        // błąd (false), sukces (true)
        bool bit_set_multi_low(uint16_t * pos, uint16_t size){
            if(pos == nullptr || size > _size) return false;
            T backup = _reg;
            for(uint16_t i = 0; i < size; i++) if(pos[i] < _size){ _reg &= ~(1 << pos[i]); } else {_reg = backup; return false; }
            return true;
        }

        // błąd (false), sukces (true)
        bool bit_set_multi_hi(uint16_t * pos, uint16_t size){
            if(pos == nullptr || size > _size) return false;
            T backup = _reg;
            for(uint16_t i = 0; i < size; i++) if(pos[i] < _size){ _reg |= (1 << pos[i]); } else {_reg = backup; return false; }
            return true;
        }

        uint16_t bit_length() const noexcept{
            return _size;
        }
};

int main(){
    bitx<> reg = 0x0; // domyślnie "uint16_t" w nawiasie <>

    cout << "> liczba bitów w zmiennej, zakres [0-15]: " << reg.bit_length() << endl;
    cout << "> początkowa wartość rejestru: " << reg << endl;

    uint16_t pos1 [] = {0, 2, 4, 6, 8, 10, 12}; // tablica bitów
    cout << "\n> ustawiam bity [0, 2, 4, 6, 8, 10, 12] na high ... " << (reg.bit_set_multi_hi(pos1, sizeof(pos1)/sizeof(uint16_t)) ? "[ok]" : "[błąd]") << endl;
    cout << "> wartość rejestru: " << reg << endl;

    cout << "\n> ustawiam bit7 na high ... " << (reg.bit_set(7, true) ? "[ok]" : "[błąd]") << endl;
    cout << "> wartość rejestru: " << reg << endl;

    cout << "\n> ustawiam bit8 na low ... " << (reg.bit_set(8, false) ? "[ok]" : "[błąd]") << endl;
    cout << "> wartość rejestru: " << reg << endl;

    cout << "\n> ustawiam bit5 na high ... " << (reg.bit_set(5, true) ? "[ok]" : "[błąd]") << endl;
    cout << "> wartość rejestru: " << reg << endl;

    uint16_t pos2 [] = {4, 10};
    cout << "\n> ustawiam bity [4, 10] na low ... " << (reg.bit_set_multi_low(pos2, sizeof(pos2)/sizeof(uint16_t)) ? "[ok]" : "[błąd]") << endl;
    cout << "> wartość rejestru: " << reg << endl;

    cout << "\n> próbuję ustawić bit20 (poza zakresem) na high: " << (reg.bit_set(20, true) ? "[ok]" : "[błąd]") << endl;
    cout << "> wartość rejestru po nieudanej próbie: " << reg << endl;

    cout << "\n> sprawdzam bit3 [" << reg.bit_get(3) << "] i bit7 [" << reg.bit_get(7) << "]\n";

    reg = 0x0;
    cout << "\n> zeruję rejestr, teraz ma wartość: " << reg << endl;

    return 0;
}