cpp implementation of range based enumeration

enumerate.cpp

#include <tuple>

template <typename T, 
          typename IterType = decltype(std::declval<T>().begin())>
struct Enumerate {
    T object;
    IterType iter_begin;
    IterType iter_end;
    size_t size;

    Enumerate(T&& given) : 
        object(std::forward<T>(given)), 
        iter_begin(object.begin()), 
        iter_end(object.end()),
        size(std::distance(iter_begin, iter_end))
    {
        // Do Nothing
    }

    struct Iterator {
        IterType iter;
        size_t now;

        auto operator*() {
            return std::make_tuple(*iter, now);
        }

        Iterator& operator++() {
            ++iter;
            ++now;
            return *this;
        }

        bool operator!=(const Iterator& other) {
            return iter != other.iter && now != other.now;
        }
    };

    auto begin() const {
        return Iterator { iter_begin, 0 };
    }

    auto end() const {
        return Iterator { iter_end, size };
    }
};