#include "stdafx.h"
#include <iostream>
#include <vector>
#include <iterator>
using namespace std;

template <typename T>
class Enumerate_Iterator
{
public:
	struct DataProxy
	{
		pair<int, T*> p;
		auto operator->()
		{
			return &p;
		}
	};

	using value_type = pair<int, T>;
	using iterator_category = std::forward_iterator_tag;
	using difference_type = std::ptrdiff_t;
	using pointer = DataProxy;
	using reference = value_type&;

	Enumerate_Iterator(T it, int idx = 0) : it_{it}, idx_{idx} {}
	Enumerate_Iterator(T it) : it_{it} {}
	Enumerate_Iterator operator++(int)
	{
		auto tmp = *this;
		++it_;
		++idx_;
		return tmp;
	}
	Enumerate_Iterator & operator++()
	{
		++it_;
		++idx_;
		return *this;
	}
	bool operator==(const Enumerate_Iterator &rhs) const
	{
		return this->it_ == rhs.it;
	}
	bool operator!=(const Enumerate_Iterator &rhs) const
	{
		return !(*this == rhs);
	}
	pair<int, T> operator*()
	{
		return pair<idx_, *it_>;
	}
	auto operator->() { return DataProxy{ idx_, *it }; }
private:
	T it_;
	int idx_{};
};

template <typename T>
class enumerate
{
public:
	enumerate(T & cont) : cont{cont} {}
	Enumerate_Iterator<typename T::iterator> begin() { return std::begin(cont); }
	Enumerate_Iterator<typename T::iterator> end() { return std::end(cont); }
private:
	T & cont;
};


int main()
{
	std::vector<int> vals{ 2,3,2,4,6,7 };

	for (auto &&[idx, val] : enumerate<std::vector<int> >(vals))
		cout << idx << ": " << val++ << endl;

	for (auto i : vals)
		cout << i << ' ';
	cout << endl;

	for (auto[index, value] : enumerate<std::vector<int> >(vals))
		cout << index << ": " << value << endl;

	Enumerate_Iterator<std::vector<int> > it{ begin(vals) };
	cout << '\n' << it->first << ' ' << it->second << '\n';
	++it;
	cout << it->first;
}