c++ BitArray 的实现

#ifndef _BIT_ARRAY_H
#define _BIT_ARRAY_H

#include <string.h>
#include <stdexcept>

namespace utils
{
    const char bit_one[] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };
    const char bit_zero[] = { 0xFE, 0xFC, 0xFB, 0xF7, 0xEF, 0xCF, 0xBF, 0x7F };

    class BitArray
    {
    public:
        BitArray();
        BitArray(size_t length);
        BitArray(const BitArray& other);
        BitArray(BitArray&& other)noexcept;
        ~BitArray();

        void setBit(size_t index);
        void setBit(int i, bool value);
        void clearBit(size_t index);
        void setAll(bool value);
        bool at(size_t index);

        const char* bits() const { return m_bitarray; };
        size_t size() { return m_length; }
        void resize(size_t size);

        bool operator [](size_t index);
        BitArray& operator = (const BitArray& other);
        BitArray& operator = (BitArray&& other)noexcept;
    private:
        size_t m_length;
        char* m_bitarray;

        size_t number_of_bytes(size_t size) {return ceil(m_length / 8.0);};
    };


    BitArray::BitArray()
    {
        m_length = 0;
        m_bitarray = nullptr;
    }

    BitArray::BitArray(size_t length)
    {
        m_length = length;
        size_t nb = number_of_bytes(length);
        m_bitarray = new char[nb];
    }

    BitArray::BitArray(const BitArray& other)
    {
        m_length = other.m_length;
        size_t nb = number_of_bytes(m_length);
        m_bitarray = new char[nb];

        memcpy(m_bitarray, other.m_bitarray, nb);
    }

    BitArray::BitArray(BitArray&& other) noexcept
    {
        m_length = other.m_length;
        m_bitarray = other.m_bitarray;
        other.m_length = 0;
        other.m_bitarray = nullptr;
    }

    BitArray::~BitArray()
    {
        if (m_bitarray){
            delete[]m_bitarray;
        }
    }

    void BitArray::setBit(size_t index)
    {
        if (index >= m_length){
            throw std::out_of_range("index out of range");
        }
        size_t offset = index >> 3;
        size_t bit = index & 0x07;

        m_bitarray[offset] |= bit_one[bit];
    }

    void BitArray::setBit(int i, bool value)
    {
        if (value)
            setBit(i);
        else
            clearBit(i);
    }

    void BitArray::clearBit(size_t index)
    {
        if (index >= m_length){
            throw std::out_of_range("index out of range");
        }
        size_t offset = index >> 3;
        size_t bit = index & 0x07;

        m_bitarray[offset] &= bit_zero[bit];
    }

    void BitArray::setAll(bool value)
    {
        size_t nb = number_of_bytes(m_length);
        for (size_t i = 0; i < nb; i++) {
            m_bitarray[i] = value ? 0xFF : 0x00;
        }
    }

    bool BitArray::at(size_t index)
    {
        if (index >= m_length){
            throw std::out_of_range("index out of range");
        }
        size_t offset = index >> 3;
        size_t bit = index & 0x07;
        return m_bitarray[offset] & bit_one[bit];
    }

    void BitArray::resize(size_t size)
    {    
        if (size <= 0)
            return;
        if (size == m_length)
            return;

        size_t length_old = m_length;
        char* bitarray_old = m_bitarray;
        size_t nb_old = number_of_bytes(length_old);

        m_length = size;
        size_t nb_new = number_of_bytes(m_length);
        m_bitarray = new char[nb_new];

        if (bitarray_old){
            memcpy(m_bitarray, bitarray_old, std::min(nb_new, nb_old));
            delete[] bitarray_old;
        }            
    }

    bool BitArray::operator [](size_t index)
    {
        return at(index);
    }

    BitArray& BitArray::operator = (const BitArray& other) {
        if (this == &other)
            return *this;

        if (m_bitarray)
        {
            delete[]m_bitarray;
            m_bitarray = nullptr;
        }

        m_length = other.m_length;
        size_t nb = number_of_bytes(m_length);
        m_bitarray = new char[nb];
         
        memcpy(m_bitarray, other.m_bitarray, nb);

        return *this;
    }

    BitArray& BitArray::operator = (BitArray&& other) noexcept {
        if (this == &other)
            return *this;

        m_length = other.m_length;
        m_bitarray = other.m_bitarray;
        other.m_length = 0;
        other.m_bitarray = nullptr;

        return *this;
    }
} 

#endif // !_BIT_ARRAY_H

BitArray是位数组，它提供对单个位的访问和设置

    utils::BitArray bit(100);
    bit.setAll(false);
    bit.setBit(23);
    bit.setBit(24,true);
    bit.clearBit(24);
    bool b = bit.at(24);
    for (int i = 0; i < bit.size(); ++i) {
        std::cout << bit[i] << std::endl;
    }