ЮБ>>        return data_[i_-1] + data_[i_++ -2];
А>

        int rc = data_[i_-1] + data_[i_-2];
        ++i_;
        return rc;

ЮБ>struct miner {
ЮБ>    int * data_;
ЮБ>    size_t i_;
ЮБ>    miner(int * data) : data_(data), i_(0) { data_[0] = data_[1] = 1; } 
ЮБ>    int operator()(int) {
ЮБ>        if (i_ < 2)
ЮБ>            return ++i_, 1;
ЮБ>        return data_[i_-1] + data_[i_++ -2];
ЮБ>    }
ЮБ>};

ЮБ>int main(int argc, char* argv[])
ЮБ>{
ЮБ>    int d[10] = {0};
ЮБ>    std::copy(d, std::transform(d, d+10, d, miner(d)), std::ostream_iterator<int>(std::cout, "\n")); // имхо так красивше

ЮБ>    return 0;
ЮБ>}

class VIterator
{
public:
    bool    m_break;
    VIterator()
        : m_break(false)
    {
    }
};

template <class TIterator>
class VIteratorImpl : public VIterator
{
public:
    TIterator    m_p;

    VIteratorImpl(TIterator p)
        : m_p(p)
    {
    }
};

template <class TIterator>
inline VIteratorImpl<TIterator>    vIteratorInit(TIterator pStart)
{
    return VIteratorImpl<TIterator>(pStart);
}

template <class TIterator>
inline bool    vIteratorCanContinue(VIterator & pIter, TIterator pEnd)
{
    return static_cast<VIteratorImpl<TIterator>& >(pIter).m_p != pEnd;
}

template <class TIterator>
inline void    vIteratorStep(VIterator & pIter, TIterator pEnd)
{
    ++static_cast<VIteratorImpl<TIterator>& >(pIter).m_p;
}

template <class TIterator>
inline typename TIterator::reference vIteratorGetValue(VIterator & pIter, TIterator pEnd)
{
    pIter.m_break = true;
    return *static_cast<VIteratorImpl<TIterator> & >(pIter).m_p;
}



#define FOREACH(varDef, collection)\
    for(\
        VIterator & pIterator = vIteratorInit(collection.begin());\
        !pIterator.m_break && vIteratorCanContinue(pIterator, collection.end());\
        vIteratorStep(pIterator, collection.end())\
        )\
        for(varDef = vIteratorGetValue(pIterator, collection.end()); pIterator.m_break; pIterator.m_break = false)

int _tmain(int argc, _TCHAR* argv[])
{
    std::vector<int> col;
    col.push_back(10);
    col.push_back(20);
    col.push_back(30);

    FOREACH(int val, col)
    {
        printf("%d\n", val);
    }

    return 0;
}

class VIterator
{
public:
    bool    m_break;
    bool    m_end;
    VIterator(bool end)
        : m_break(false), m_end(end)
    {
    }
};

template <class TIterator>
class VIteratorImpl : public VIterator
{
public:
    TIterator    m_p;

    VIteratorImpl(TIterator p, TIterator pEnd)
        : m_p(p), VIterator(p == pEnd)
    {
    }
};

template <class TIterator>
inline VIteratorImpl<TIterator>    vIteratorInit(TIterator pStart, TIterator pEnd)
{
    return VIteratorImpl<TIterator>(pStart, pEnd);
}


template <class TIterator>
inline void    vIteratorStep(VIterator & pIter, TIterator pEnd)
{
    ++static_cast<VIteratorImpl<TIterator>& >(pIter).m_p;
}

template <class TIterator>
inline typename TIterator::reference vIteratorGetValue(VIterator & pIter, TIterator pEnd)
{
    pIter.m_break = true;
    TIterator::reference ret = *static_cast<VIteratorImpl<TIterator> & >(pIter).m_p;
    pIter.m_end = (pEnd == ++static_cast<VIteratorImpl<TIterator> & >(pIter).m_p);
    return ret;
}



#define FOREACH(varDef, collection)\
    for(\
        VIterator & pIterator = vIteratorInit(collection.begin(), collection.end());\
        !pIterator.m_end && !pIterator.m_break;\
        )\
        for(varDef = vIteratorGetValue(pIterator, collection.end()); pIterator.m_break; pIterator.m_break = false)

L>>#define FOREACH(varDef, collection)\
L>>    for(\
L>>        VIterator & pIterator = vIteratorInit(collection.begin(), collection.end());\
L>>        !pIterator.m_end && !pIterator.m_break;\
L>>        )\
L>>        for(varDef = vIteratorGetValue(pIterator, collection.end()); pIterator.m_break; pIterator.m_break = false)
L>>

#include <stdio.h>

class Base{
};

class Derived:public Base{
public:
  Derived(){printf("C\n");}
  Derived(const Derived& d){printf("CC\n");}
  ~Derived(){printf("D\n");}
};

Derived getD()
{
  return Derived();
}

int main(int argc,char* argv[])
{
  Base& b=getD();
  printf("hello!\n");
  return 0;
}

L>>>#define FOREACH(varDef, collection)\
L>>>    for(\
L>>>        VIterator & pIterator = vIteratorInit(collection.begin(), collection.end());\
L>>>        !pIterator.m_end && !pIterator.m_break;\
L>>>        )\
L>>>        for(varDef = vIteratorGetValue(pIterator, collection.end()); pIterator.m_break; pIterator.m_break = false)
L>>>

EX>#include <stdio.h>

EX>class Base{
EX>};

EX>class Derived:public Base{
EX>public:
EX>  Derived(){printf("C\n");}
EX>  Derived(const Derived& d){printf("CC\n");}
EX>  ~Derived(){printf("D\n");}
EX>};

EX>Derived getD()
EX>{
EX>  return Derived();
EX>}

EX>int main(int argc,char* argv[])
EX>{
EX>  Base& b=getD();
EX>  printf("hello!\n");
EX>  return 0;
EX>}
EX>

EX>

A reference to type ``cv1 T1'' is initialized by an expression of type ``cv2 T2'' as follows:

If the initializer expression
— is an lvalue (but is not a bit-field), and ``cv1 T1'' is reference-compatible with ``cv2 T2,'' or
— has a class type (i.e., T2 is a class type) and can be implicitly converted to an lvalue of type ``cv3 T3,'' where ``cv1 T1'' is reference-compatible with ``cv3 T3'' *

[Footnote: This requires a conversion function (class.conv.fct) returning a reference type. --- end foonote]

  void f(A & val);
  
...
  f(A());