class ShiftedStream
{
    BYTE const* data;
    int length;
    int bytePos, bitPos;
    
    BYTE leadBits() const { return bytePos<=0 || bytePos>length ? 0 : data[bytePos]>>bitPos; }
    BYTE tailBits() const { return bytePos<0 || bytePos>=length ? 0 : data[bytePos+1]<<(8-bitPos); }
public:
    BYTE peek() const { return leadBits() | tailBits(); }
    BYTE read() { BYTE b = peek(); ++bytePos; }
};

p = p + 0.25;

struct BitPointer
{
   char* address;
   char bitnumber;
};

R>p = p + 0.25;
R>

R>

#include <iostream>
#include <limits>
#include <iterator>
#include <bitset>

template< int shift = 0 >
struct shift_iterator
{
    typedef std::random_access_iterator_tag iterator_category;
    typedef unsigned long value_type;
    struct reference;
    typedef ptrdiff_t difference_type;

    value_type * ptr;

    shift_iterator ( value_type * src ) : ptr (src) {}

    reference operator * () const { return reference (this->ptr); }
    reference operator [] (difference_type) const;

    template<typename T>
    struct temporary {
        T value;
        explicit temporary ( T src ) : value (src) {}

        T * operator -> () { return & this->value; }
    };
    temporary<reference> operator -> () const { return temporary<reference> ( reference (this->ptr) ); }


    shift_iterator & operator ++ () { ++this->ptr; return (*this); }
    shift_iterator & operator -- () { --this->ptr; return (*this); }

    shift_iterator operator ++ (int) { shift_iterator tmp (*this); ++(*this); return tmp; }
    shift_iterator operator -- (int) { shift_iterator tmp (*this); --(*this); return tmp; }

    shift_iterator & operator += ( difference_type n ) { this->ptr += n; return (*this); }
    shift_iterator & operator -= ( difference_type n ) { this->ptr -= n; return (*this); }
};

template< int shift >
struct shift_iterator<shift>::reference {
    static const int digits = std::numeric_limits<value_type>::digits;
    typedef std::bitset<digits> bitset;


    value_type * ptr;
    reference ( value_type * src ) : ptr (src) {}
    value_type value () const { 

        std::cout << __FUNCTION__ << std::endl;

        bitset tmp (*this->ptr); // берем текущий элемент.
        std::cout << tmp.to_ulong () << ":" << tmp << std::endl;
        bitset val = tmp >> shift; // удаляем хвост предынущего элемента. теперь val хранит младшую часть значения.
        std::cout << val.to_ulong () << ":" << val << std::endl;

        tmp = *(this->ptr+1); // берем следующий элемент.
        std::cout << tmp.to_ulong () << ":" << tmp << std::endl;
        tmp = (tmp << digits-shift); // получаем старшую чась значения.
        std::cout << tmp.to_ulong () << ":" << tmp << std::endl;
        val |= tmp; // склеиваем младшую и старшую части.
        std::cout << val.to_ulong () << ":" << val << std::endl;

        return val.to_ulong ();  // возвращаем значение.
    }

    operator value_type () const { return this->value (); }

    reference & operator = ( value_type value ) { 
        static bitset const mask = bitset ().set(); // все единицы
        static bitset const hmask= mask << shift; // старшая часть = единицы
        static bitset const lmask= ~ hmask; // младшая часть = единицы

        std::cout << __FUNCTION__ << std::endl;

        std::cout << lmask << std::endl;
        std::cout << hmask << std::endl;

        bitset tmp (*this->ptr); // берем текущий элемент.
        bitset val (value); // и новое значение.

        std::cout << tmp.to_ulong () << ":" << tmp << std::endl;
        std::cout << val.to_ulong () << ":" << val << std::endl;
        val = ( val << shift ) | ( val >> digits-shift ); // для удобства сдвигаем циклически новое значение на число бит.
        std::cout << val << std::endl;
        tmp = ( tmp & lmask ) | ( val & hmask ); // склеиваем хвост предыдущего элемента и младшую часть нового значения.
        std::cout << tmp << std::endl;
        *this->ptr = tmp.to_ulong (); // записываем в текущий элемент это значение.

        tmp = *(this->ptr+1); // берем следующий элемент.
        std::cout << tmp.to_ulong () << ":" << tmp << std::endl;
        tmp = ( val & lmask ) | ( tmp & hmask ); // склеиваем старшую часть нового значения и начало следующего элемента.
        std::cout << tmp << std::endl;
        *(this->ptr+1) = tmp.to_ulong (); // записываем полученное значение в массив.

        return (*this); 
    }

};

int main() { 
    unsigned long x[4] = {7,5,3,5};
    shift_iterator<2> it (x);
    std::cout << it->value () << std::endl;
    *it = std::numeric_limits<unsigned long>::max()-4;

    return 0;
}

NB>Кто до сюда дочитал, критикуйте

template<class Base, int ShiftBits, class CharType = boost::iterator_value<Base>::type>
class shift_iter : 
    public boost::iterator_adaptor<
        shift_iter<Base, ShiftBits, CharType>,
        Base, CharType, boost::single_pass_traversal_tag, CharType>
{
public:
    template<class T>
        shift_iter(T start) 
        : boost::iterator_adaptor<shift_iter<Base, ShiftBits, CharType>,
        Base, CharType, boost::single_pass_traversal_tag, CharType>
        (Base(start))
        , m_first(true)
    {}

private:
    CharType dereference() const 
    {
        if (m_first)
        {
            m_buffer = *const_cast<shift_iter*>(this)->base_reference();
            ++(const_cast<shift_iter*>(this)->base_reference());
            m_first = false;
        }

        m_last_buffer = m_buffer;
        m_buffer = *const_cast<shift_iter*>(this)->base_reference();

        CharType retval = m_last_buffer << ShiftBits;
        retval += (unsigned)m_buffer >> (sizeof(base_value_type)*8-ShiftBits);
        return retval;
    }

    typedef typename boost::iterator_value<Base>::type base_value_type;
    mutable base_value_type m_buffer;
    mutable base_value_type m_last_buffer;
    mutable bool m_first;
    friend class boost::iterator_core_access;
};

void test()
{
    byte data[] = {0x79, 0xe3, 0x11, 0xa5};

    {
        const byte* first = data;
        const byte* const last = data + sizeof(data)/sizeof(*data);
        for (; first != last; ++first)
            std::cout << to_hex(*first).c_str() << " ";
        std::cout << std::endl;
    }

    {
        typedef boost::archive::iterators::transform_width<
            shift_iter<byte*, 3>, 4, 8> my_iter;

        my_iter first (data);
        my_iter last (data + sizeof(data)/sizeof(*data));

        for (; first != last; ++first)
            std::cout << to_hex(*first).c_str() << " ";
        std::cout << std::endl;
    }
}

79 E3 11 A5
0C 0F 01 08 08 0D

NB>>Кто до сюда дочитал, критикуйте

R>Слишком много кода

R>        CharType retval = m_last_buffer << ShiftBits;
сдвигаем прошлое значение на ShiftBits получаем старшие разряды.

R>        retval += (unsigned)m_buffer >> (sizeof(base_value_type)*8-ShiftBits);
сдвигаем новое значение на 32-ShiftBits получаем младшие разряды. склеиваем.
может необходимо результат сдвинуть циклисески, чтобы из прошлое значение соответствовало
младшим разрядам?

NB>видимо я неправильно понял задание

R>>        CharType retval = m_last_buffer << ShiftBits;
NB>сдвигаем прошлое значение на ShiftBits получаем старшие разряды.

R>>        retval += (unsigned)m_buffer >> (sizeof(base_value_type)*8-ShiftBits);
NB>сдвигаем новое значение на 32-ShiftBits получаем младшие разряды. склеиваем.
NB>может необходимо результат сдвинуть циклисески, чтобы из прошлое значение соответствовало
NB>младшим разрядам?
NB>

typedef transform_width<shr_iter<shift_iter<byte*, 3>, 4, 8, 2> my_iter;

A_A>>Думал реализовать с использованием шаблона bitset<size_t N>, но у него фиксированный размер

unsigned char ch = 0xF0;

dynamic_bitset<> dbs1(1000);
dbs1 <<= sizeof(unsigned char);

dbs1 |= ch; //не работает, когда хочу добавить 8 бит в конец битсета

dynamic_bitset<> dbs_for_ch_storage(8, static_cast<unsigned long int>(ch));
dbs1 |= dbs_for_ch_storage; //не работает(вернее кидает exception), ибо если dbs1 1000 бит, то и dbs_for_ch_storage должен быть 1000 бит

dynamic_bitset<> dbs_for_ch_storage(1000, static_cast<unsigned long int>(ch));
dbs1 |= dbs_for_ch_storage;

A_A>unsigned char ch = 0xF0;

A_A>dynamic_bitset<> dbs1(1000);

если работаешь с чарами, то наверно dynamic_bitset<unsigned char>

A_A>dbs1 <<= sizeof(unsigned char);

если ты думаешь, что он сдвинет на 8 бит, то должен огорчить. sizeof(unsigned char) == 1;
используй std::numeric_limits<unsigned char>::digints;

A_A>dbs1 |= ch; //не работает, когда хочу добавить 8 бит в конец битсета

если хочешь добавить в конец, то для этого есть функция append (Block).