Опять итераторы

    T& operator[] (int i)
    {
        int ind = (i + head) % buffSize;
        return buff[ind];
    }

template <typename T, size_t Capacity>
class Buffer
{
public:
    class Iterator {
        friend class Buffer;
    public:    
        Iterator& operator++() 
        {
            index += 1;
            return *this;    
        }
        
        bool operator!=(Iterator const& other) const
        {
            return index != other.index;
        }
        
        T& operator*() 
        {
            return owner.m_buff[index % Capacity];
        }
        
    private:
        Iterator(Buffer& owner, int idx)
            : index(idx), owner(owner)
        { }
        
    private:
        int index;
        Buffer& owner;  
    };
    
    Buffer() : m_buff()
    { }
    
    T& operator[](int i)
    {
        assert(i < size());
        return m_buff[(i + m_head) % Capacity];        
    }
    
    void push_back(T const& value)
    {
        int idx = (m_head + size()) % Capacity;
        if(m_size < Capacity) {
            ++m_size;
        }
        m_buff[idx] = value;
    }
    
    void pop_back()
    {
        if(m_size > 0) {
            --m_size;
        }
    }
 
    Iterator begin() 
    {
        return Iterator(*this, m_head);
    }
    Iterator end() 
    {
        return Iterator(*this, m_head + size());
    }
    
    int size() const
    {
        return m_size;
    }
    
private:
    T m_buff[Capacity];
    
    int m_head = 0;
    int m_size = 0;
};
 
template <typename T>
void print(T & cb) {
    for(auto& v : cb)
    {
        std::cout << v << ' ';
    }
    std::cout << '\n';    
}
int main()
{
    Buffer<int, 3> cb;
 
    cb.push_back(1);
    cb.push_back(2);
    cb.push_back(3);
 
    print(cb);
    
    cb.push_back(4);
    
    print(cb);
    
    cb.pop_back();
    cb.pop_back();
    
    print(cb);
 
    cb.push_back(5);
    cb.push_back(6);
    cb.push_back(7);
    
    print(cb);
}