Question

How can be realized the auto keyword functionality without using c++0x standard?

for(std::deque<std::pair<int, int> >::iterator it = points.begin();
    it != points.end(); ++it)
{
   ...
}

Maybe such class:

class AUTO
{
public:
   template <typename T1>
   AUTO(T1);

   template <typename T2>
   operator T2();
};

With such usage:

for(AUTO it = points.begin(); it != points.end(); ++it)
{
   ...
}

But, T1 and T2 are different.
How to move info about T1 to operator T2()?
Is it really possible?

Answer 1

If a library extension was easily implementable there would have been no need for a language extension. See N1607 for details on the auto proposal.

However, the article on the Boost.Foreach (which sort of does what you want) macro may help understand the issues related to such an implementation.

What is BOOST_FOREACH?

In C++, writing a loop that iterates
over a sequence is tedious. We can
either use iterators, which requires a
considerable amount of boiler-plate,
or we can use the std::for_each()
algorithm and move our loop body into
a predicate, which requires no less
boiler-plate and forces us to move our
logic far from where it will be used.
In contrast, some other languages,
like Perl, provide a dedicated
“foreach” construct that automates
this process. BOOST_FOREACH is just
such a construct for C++. It iterates
over sequences for us, freeing us from
having to deal directly with iterators
or write predicates.

BOOST_FOREACH is designed for
ease-of-use and efficiency. It does no
dynamic allocations, makes no virtual
function calls or calls through
function pointers, and makes no calls
that are not transparent to the
compiler’s optimizer. This results in
near-optimal code generation; the
performance of BOOST_FOREACH is
usually within a few percent of the
equivalent hand-coded loop. And
although BOOST_FOREACH is a macro, it
is a remarkably well-behaved one. It
evaluates its arguments exactly once,
leading to no nasty surprises.