Lazy zipper

#include <iostream>
#include <vector>
#include <tuple>

template <class T, class Y>
class zipper {
        class iterator {
        public:
                iterator(typename T::iterator tIt, typename Y::iterator yIt) : tIt(tIt), yIt(yIt) {}
                bool operator==(const iterator &i) {
                        return (tIt==i.tIt || yIt==i.yIt);
                }
                std::tuple<typename T::value_type&, typename Y::value_type&> operator*() {
                        return std::forward_as_tuple(*tIt, *yIt);
                }
                iterator& operator++() {
                        ++tIt;
                        ++yIt;
                        return *this;
                }
                iterator operator++(int) {
                        iterator tmp = *this;
                        ++*this;
                        return tmp;
                }
                bool operator!=(const iterator &i) {
                        return (tIt!=i.tIt && yIt!=i.yIt);
                }
        private:
                typename T::iterator tIt;
                typename Y::iterator yIt;
        };
        T& t;
        Y& y;
public:
        zipper(T& t, Y& y) : t(t), y(y) {}
        iterator begin() { return iterator(t.begin(), y.begin()); }
        iterator end() { return iterator(t.end(), y.end()); }
};

template<class T, class Y>
zipper<T,Y> zip(T& t, Y& y) { return zipper<T,Y>(t, y); }

using namespace std;

int main() {
        vector<int> v{0,1,2};
        vector<string> u{"five","four","three","two","one"};
        for ( auto x : zip(u,v) ) {
                cout << get<0>(x) << "\t" << get<1>(x) << endl;
        }
}

/* Output:
 * "five    0"
 * "four    1"
 * "three   2"
 */