Bool向量实现

Question

有人可以告诉我这个向量实际上是如何工作的吗？特别是关于其operator=类的operator bool和VecProxy以及主类的operator[]。我知道减少内存使用量是必需的。就像bool是1字节一样，使用此类，我们可以为每个元素将其减少7位。我猜想VecProxy需要分配每一位。

所以，这是代码：

template <>
class Vector<bool>
{
private:
    typedef unsigned char byte;
    size_t _size;
    size_t _capacity;
    size_t _byte_size;
    byte* _data;
public:
    Vector(size_t capacity = 0) : _size(0),
        _capacity(capacity),
        _byte_size(0),
        _data(nullptr)
    {
        if (capacity > 0)
        {
            _data = new byte[capacity / 8 + (capacity % 8 != 0)];
            if (!_data) throw "Out of memory";
        }
    }

    class VecProxy
    {
        size_t _idx;
        byte* _vec_ptr;
    public:
        VecProxy(size_t idx, byte* vecPtr) : _idx(idx), _vec_ptr(vecPtr) {}
        VecProxy& operator=(bool val)
        {
            size_t char_idx = _idx / 8;
            size_t bit_idx = _idx % 8;
            if (val)
                _vec_ptr[char_idx] |= 1 << bit_idx;
            else
                _vec_ptr[char_idx] &= ~(1 << bit_idx);
            return *this;
        }

        operator bool()
        {
            size_t char_idx = _idx / 8;
            size_t bit_idx = _idx % 8;
            return (_vec_ptr[char_idx] >> char_idx) & 0x01;
        }
    };

    VecProxy operator[](size_t idx)
    {
        if (idx >= _size) throw "Out of bounds";
        return VecProxy(idx, _data);
    }

    Vector& resize(size_t new_size)
    {
        _capacity = new_size;
        _size = _capacity < _size ? _capacity : _size;
        _byte_size = _size / 8 + (_size % 8 != 0);
        byte* tmp = new byte[_capacity / 8 + (_capacity % 8 != 0)];
        if (!tmp) throw "Out of memory";
        for (size_t i = 0; i < _byte_size; ++i)
            tmp[i] = _data[i];
        if (!_data)
            delete[] _data;
        _data = tmp;
    }

    Vector& push_back(bool val)
    {
        if (_size == _capacity)
        {
            if (_capacity < 10)
                resize(_capacity + 10);
            else
                resize(_capacity * 1.5);
        }
        VecProxy(_size++, _data) = val;
        return *this;
    }
};

我有template<>一定有点令人困惑。但是在.h文件的其他部分中放置了标准vector的主要实现。

所以，我想指定我的问题：

operator=类的VecProxy中实际发生了什么？我对if感到非常困惑。
return的operator bool()语句不清楚。
但是我实际上知道了operator[]。