namespace _foreach
{

class base {};

template <typename T>
struct wrapper : public base
{
  mutable T wrapped;
  wrapper(const T& t): wrapped(t) {}
};

template <typename T> 
wrapper<T> wrap(const T& t)
{ return t; }

template <typename T>
T& unwrap(const base& b, const T&)
{ return static_cast<const wrapper<T>&>(b).wrapped; }

} // end namespace foreach

#define FOR_EACH_(Decl, First, Last) \
if (false) {} else /*VC6 for-init-scope bug workaround*/ \
  for (const _foreach::base &_fe_cur = _foreach::wrap(First), &_fe_last = _foreach::wrap(Last); \
    _foreach::unwrap(_fe_cur, First) != _foreach::unwrap(_fe_last, Last); \
      ++_foreach::unwrap(_fe_cur, First)) \
        if (bool _fe_once = false) {} else \
          for (Decl = *_foreach::unwrap(_fe_cur, First); !_fe_once; _fe_once = true)    \
// end macro

#define FOR_EACH(Decl, Cont)    FOR_EACH_(Decl, (Cont).begin(), (Cont).end())

#include <vector>
#include <set>
#include <string>
#include <iostream>

using namespace std;

int main(int argc, const char* argv[])
{
    std::set<std::string> str_set;
    str_set.insert("red");
    str_set.insert("green");
    str_set.insert("blue");
    FOR_EACH(const string& s, str_set) cout << s << endl;

    std::vector<short> short_vec;
    short_vec.push_back(-2);
    short_vec.push_back(-1);
    short_vec.push_back(0);
    FOR_EACH(short& i, short_vec) ++i;
    FOR_EACH(int i, short_vec)
    {
        if (i >= 0 && i < argc) cout << argv[i] << endl;
        else cout << i << endl;
    }
    return 0;
}

ЮБ>Чем функторы то так не нравятся, рульно же когда цикл в одном месте а алгоритм в другом — нафига обртно все в кучу упихивать то?

/* main.cpp */ 

#include <iostream>

using namespace std;

#define dimof(v) ((sizeof v)/(sizeof *v))

/* main() */ 

int main()
 {
  int v[10];
  
  v[0]=v[1]=1;
  
  for(int *p=v+2,*lim=v+dimof(v); p<lim ;p++) *p=p[-1]+p[-2];
  
  for(int *p=v,*lim=v+dimof(v); p<lim ;p++) cout << *p << endl ;
 
  return 0;
 }

Fun F;

for_each(...,F);

/* for(...) F(*p); */

template <class Fun>
struct Adapter
 {
  Fun *ptr;

  Adapter(Fun &object) : ptr(&object) {}

  template <class T>
  void operator (T x) { (*ptr)(x); } 
 };

template <class Fun>
struct AdapterRef
 {
  Fun *ptr;

  AdapterRef(Fun &object) : ptr(&object) {}

  template <class T>
  void operator (T &x) { (*ptr)(x); } 
 };

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;
}

#include "stdafx.h"
namespace foreach_detail
{
    struct wrapper_holder{};

    template <typename T>
    struct wrapper
        :wrapper_holder
    {
        mutable T wrapped;
        wrapper(const T& t)
            :wrapped(t) 
        {}
    };

    template <typename T> 
    wrapper<T> wrap(const T& t)
    { 
        return t; 
    }

    template <typename T>
    T& unwrap(const wrapper_holder& b)
    { 
        return static_cast<const wrapper<T>&>(b).wrapped; 
    }

    template <typename T>
    T& unwrap(const wrapper_holder& b, const T&)
    { 
        return unwrap<T>(b); 
    }

    template <typename T>
    bool is_wrapped_equal(const wrapper_holder& lhs, const wrapper_holder& rhs, const T&)
    { 
        return unwrap<T>(lhs)==unwrap<T>(rhs);
    }
}

#define foreach_(Decl, First, Last)\
if(bool _fe_break = false){}else \
    for(const foreach_detail::wrapper_holder\
             &_fe_cur=foreach_detail::wrap(First)\
            ,&_fe_end=foreach_detail::wrap(Last)\
        ;!foreach_detail::is_wrapped_equal(_fe_cur, _fe_end, Last)&&!_fe_break\
        ;++foreach_detail::unwrap(_fe_cur, Last)\
        )\
        if(!(_fe_break=true)){}else\
        for(Decl=*foreach_detail::unwrap(_fe_cur, Last);_fe_break;_fe_break=false)\
// end macro

#define foreach(Decl, Cont)    foreach_(Decl, (Cont).begin(), (Cont).end())

        if(!(_fe_break=true)){}else\
        for(Decl=*foreach_detail::unwrap(_fe_cur, Last);_fe_break;_fe_break=false)\

        for(Decl=*foreach_detail::unwrap(_fe_cur, Last);_fe_break=!_fe_break;)\

    std::vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.push_back(5);

    int s=1;
    foreach(int& i, v)
    {
        s*=i;
    }

    cmp    edi, esi
    push    ebp
    mov    ecx, 1
    mov    ebp, edi
    je    SHORT $L10897
    push    ebx
$L20823:
    mov    edx, DWORD PTR [ebp]
    mov    al, 1
$L10901:

; 68   :     {
; 69   :         s*=i;

    mov    ebx, edx
    imul    ecx, ebx
    test    al, al
    sete    al
    test    al, al
    jne    SHORT $L10901
    add    ebp, 4
    cmp    ebp, esi
    jne    SHORT $L20823
    pop    ebx
$L10897:

    cmp    edi, esi
    mov    eax, 1
    mov    ecx, edi
    je    SHORT $L10897
$L20663:

; 69   :     {
; 70   :         s*=i;

    mov    edx, DWORD PTR [ecx]
    add    ecx, 4
    imul    eax, edx
    cmp    ecx, esi
    jne    SHORT $L20663
$L10897:

    s=1;
    for(std::vector<int>::iterator i=v.begin(), e=v.end();i!=e;++i)
    {
        s*=*i;
    }

    cmp    edi, esi
    mov    ecx, 1
    mov    eax, edi
    je    SHORT $L10964
$L20765:

; 76   :     {
; 77   :         s*=*i;

    mov    edx, DWORD PTR [eax]
    add    eax, 4
    imul    ecx, edx
    cmp    eax, esi
    jne    SHORT $L20765
$L10964:

    int s=1;
    foreach(int& i, v)
    {
        if(i==3)break;
        s*=i;
    }

    s=1;
    for(std::vector<int>::iterator i=v.begin(), e=v.end();i!=e;++i)
    {
        if(*i==3)break;
        s*=*i;
    }

; 67   :     int s=1;
; 68   :     foreach(int& i, v)

    xor    cl, cl
    cmp    edi, esi
    mov    edx, edi
    je    SHORT $L10897
    npad    5
$L20665:
    cmp    cl, bl
    jne    SHORT $L10897

; 69   :     {
; 70   :         if(i==3)break;

    mov    eax, DWORD PTR [edx]
    cmp    eax, 3
    mov    cl, 1
    je    SHORT $L10896

; 71   :         s*=i;

    imul    eax, ebp
    mov    ebp, eax
    xor    cl, cl
$L10896:
    add    edx, 4
    cmp    edx, esi
    jne    SHORT $L20665
$L10897:

; 74   : 
; 75   :     s=1;
; 76   :     for(std::vector<int>::iterator i=v.begin(), e=v.end();i!=e;++i)

    cmp    edi, esi
    mov    edx, 1
    mov    ecx, edi
    je    SHORT $L20822
    npad    1
$L20767:

; 77   :     {
; 78   :         if(*i==3)break;

    mov    eax, DWORD PTR [ecx]
    cmp    eax, 3
    je    SHORT $L20822

; 79   :         s*=*i;

    imul    eax, edx
    add    ecx, 4
    cmp    ecx, esi
    mov    edx, eax
    jne    SHORT $L20767
$L20822:

//По умолчанию считаем контейнеры STL совместимыми
template<class container_t>
struct container_traits
{
    typedef typename container_t::iterator iterator;
    typedef typename container_t::const_iterator const_iterator;
};

template<class container_t>
typename container_traits<container_t>::iterator
    container_begin(container_t& container)
{
    return container.begin();
}
template<class container_t>
typename container_traits<container_t>::iterator
    container_end(container_t& container)
{
    return container.end();
}

template<class container_t>
typename container_traits<container_t>::const_iterator
    container_begin(const container_t& container)
{
    return container.begin();
}
template<class container_t>
typename container_traits<container_t>::const_iterator
    container_end(const container_t& container)
{
    return container.end();
}
//Реализация для массивов
template<class value_t, size_t size_n>
struct container_traits<value_t[size_n]>
{
    typedef typename value_t* iterator;
    typedef typename const value_t* const_iterator;
};

template<class value_t, size_t size_n>
typename container_traits<value_t[size_n]>::iterator
    container_begin(value_t(&container)[size_n])
{
    return container;
}
template<class value_t, size_t size_n>
typename container_traits<value_t[size_n]>::iterator
    container_end(value_t(&container)[size_n])
{
    return container+size_n;
}

template<class value_t, size_t size_n>
typename container_traits<value_t[size_n]>::const_iterator
    container_begin(const value_t(&container)[size_n])
{
    return container;
}
template<class value_t, size_t size_n>
typename container_traits<value_t[size_n]>::const_iterator
    container_end(const value_t(&container)[size_n])
{
    return container+size_n;
}

#define foreach(Decl, Cont)    foreach_(Decl, (Cont).begin(), (Cont).end())

#define foreach(Decl, Cont)    foreach_(Decl, container_begin(Cont), container_end(Cont))

int _tmain(int argc, _TCHAR* argv[])
{
    std::vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.push_back(5);

    foreach(int& i, v)
    {
        std::cout<<i<<" ";
    }
    std::cout<<"\n\n";
    char str[]="asd";
    foreach(char c, str)
    {
        std::cout<<c;
    }
    std::cout<<"\n\n";
    std::string strings[]={"234", "asd", "qew", "sfd", "fdsg"};
    foreach(std::string str, strings)
    {
        foreach(char c, str)
        {
            std::cout<<c;
        }
        std::cout<<"\n";
    }
    std::cout<<"\n";
    return 0;
}

1
1
2
3
5
8
13
21
34
55

1
1
2
3
5
8
13
21
34
55

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

ЮБ>>        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());

   f(A());

   {
     A tmp;
     f(tmp);
   }

 ЮБ>> 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;
 ЮБ>> }
 ЮБ>>

25.2.3/5 Notes: result may be equal to first in case of unary transform,
or to first1 or first2in case of binary transform.

1.9/7 Accessing an object designated by a volatile lvalue (3.10),
modifying an object, calling a library I/O function, or calling a function
that does any of those operations are all side effects, which are changes
in the state of the execution environment.

Requires: op and binary_op shall not invalidate iterators or subranges, or modify
elements in the ranges [first1, last1], [first2, first2 + (last1 — first1)],
and [result, result + (last1 -first1)].
[Footnote: The use of fully closed ranges is intentional --end footnote]

ПК>изысканиями формалистов-стандартизаторов

    miner(int * data) : data_(data), i_(0) { data_[0] = data_[1] = 1; }

FOR_EACH( pair<string,string>& i, mapStoS )

А>FOR_EACH( pair<string,string>& i, mapStoS )
А>

typedef std::map<std::string, std::string> mapStoS_t;
mapStoS_t mapStoS;
...
FOR_EACH(mapStoS_t::value_type& i, mapStoS) ...

А>>FOR_EACH( pair<string,string>& i, mapStoS )
А>>

F>typedef std::map<std::string, std::string> mapStoS_t;
F>mapStoS_t mapStoS;
F>...
F>FOR_EACH(mapStoS_t::value_type& i, mapStoS) ...
F>

#define CONCAT( p1, p2 )  p1##,##p2
#define FOR_EACH_M( Decl_p1, Decl_p2, Cont )  FOR_EACH( CONCAT( Decl_p1, Decl_p2 ), Cont )

// Использовать так 
FOR_EACH_M( pair<const string, string>& thePair, mapStoS )

F:\Work\prg\unnamed\include\0-utility\lang>cl a.cpp
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 13.00.9466 for 80x86
Copyright (C) Microsoft Corporation 1984-2001. All rights reserved.

a.cpp
a.cpp(43) : error C2065: 'value_t' : undeclared identifier
a.cpp(43) : error C2065: 'size_n' : undeclared identifier

standard-like containers
std::pair<iterator,iterator>
null terminated strings (this includes char[],wchar_t[], char*, and wchar_t*)
built-in arrays

#pragma once
#include "boost/range/result_iterator.hpp"
#include "boost/range/begin.hpp"
#include "boost/range/end.hpp"

namespace foreach_detail {

template<typename> struct wrapper;

// Range means SinglePassRange

struct holder
{
    template<class Range>
    typename boost::range_result_iterator<Range>::type&
        operator()( Range& ) const
    {
        typedef typename boost::range_result_iterator<Range>::type iterator;
        return static_cast<wrapper<iterator> const&>(*this).iterator_;
    }
};

template<typename Iterator>
struct wrapper : holder
{
    wrapper( Iterator iterator )
        : iterator_( iterator )
    {}
 
 private:
 friend struct holder;
    mutable Iterator iterator_;
};

template<class Range>
wrapper<typename boost::range_result_iterator<Range>::type>
    begin( Range& range )
{
    return boost::begin( range );
}

template<class Range>
wrapper<typename boost::range_result_iterator<Range>::type>
    end( Range& range )
{
    return boost::end( range );
}

} // namespace foreach_detail

#define FOR_EACH( ElementDecl, Range )\
    if( bool _fe_break = false ) {}\
    else\
    for( foreach_detail::holder const\
              &_fe_current = foreach_detail::begin(Range)\
            , &_fe_last    = foreach_detail::end(Range)\
        ; _fe_current(Range) != _fe_last(Range) && (_fe_break = !_fe_break)\
        ; ++_fe_current(Range)\
    )\
    for( ElementDecl = *_fe_current(Range); _fe_break; _fe_break = false )\
// end macro

#pragma once
#include "boost/range/iterator.hpp"
#include "boost/range/const_iterator.hpp"
#include "boost/range/begin.hpp"
#include "boost/range/end.hpp"

namespace foreach_detail {

template<typename> struct wrapper;

// Range means SinglePassRange

struct holder
{
    template<class Range>
    typename boost::range_iterator<Range>::type&
        operator()( Range& ) const
    {
        typedef typename boost::range_iterator<Range>::type iterator;
        return static_cast<wrapper<iterator> const&>(*this).iterator_;
    }

    template<class Range>
    typename boost::range_const_iterator<Range>::type&
        operator()( Range const& ) const
    {
        typedef typename boost::range_const_iterator<Range>::type iterator;
        return static_cast<wrapper<iterator> const&>(*this).iterator_;
    }
};

template<typename Iterator>
struct wrapper : holder
{
    wrapper( Iterator iterator )
        : iterator_( iterator )
    {}
 
 private:
 friend struct holder;
    mutable Iterator iterator_;
};

template<class Range>
wrapper<typename boost::range_iterator<Range>::type>
    begin( Range& range )
{
    return boost::begin( range );
}

template<class Range>
wrapper<typename boost::range_const_iterator<Range>::type>
    begin( Range const& range )
{
    return boost::begin( range );
}

template<class Range>
wrapper<typename boost::range_iterator<Range>::type>
    end( Range& range )
{
    return boost::end( range );
}

template<class Range>
wrapper<typename boost::range_const_iterator<Range>::type>
    end( Range const& range )
{
    return boost::end( range );
}

} // namespace foreach_detail

#define FOR_EACH( ElementDecl, Range )\
    if( bool _fe_break = false ) {}\
    else\
    for( foreach_detail::holder const\
              &_fe_current = foreach_detail::begin(Range)\
            , &_fe_last    = foreach_detail::end(Range)\
        ; _fe_current(Range) != _fe_last(Range) && (_fe_break = !_fe_break)\
        ; ++_fe_current(Range)\
    )\
    for( ElementDecl = *_fe_current(Range); _fe_break; _fe_break = false )\
// end macro

// ПРИМЕРЫ ИЗ ДОКУМЕНТАЦИИ
for_each(a.begin(), a.end(), std::cout << _1 << '\n');
for_each(a.begin(), a.end(), cout << ++var(index) << ':' << _1 << '\n');
// ну или так
for_each(a.begin(), a.end(), if_(_1 % 2 == 0)[ cout << _1 ]);
// или цикл
int a[5][10]; int i;
for_each(a, a+5, 
  for_loop(var(i)=0, var(i)<10, ++var(i), 
           _1[var(i)] += 1));

if_then(condition, then_part)
if_then_else(condition, then_part, else_part)
if_then_else_return(condition, then_part, else_part)
while_loop(condition, body)
while_loop(condition) // no body case
do_while_loop(condition, body)
do_while_loop(condition) // no body case 
for_loop(init, condition, increment, body)
for_loop(init, condition, increment) // no body case
switch_statement(...)

int foo(int);
for_each(v.begin(), v.end(), _1 = bind(foo, _1));

WH>Но при использовании break оптимизатор не смог избавится от оверхеда

foreach(int, i, vec) { ... }

int _tmain(int argc, _TCHAR* argv[])
{

    std::vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);

    int s=0;

    if(bool _fe_break=false) {} else
        for(int i;_fe_break==false; _fe_break=true)    // тут просто объявили
            for(const foreach_detail::wrapper_holder
                &_fe_cur=foreach_detail::wrap(v.begin()),
                &_fe_end=foreach_detail::wrap(v.end());
                !foreach_detail::is_wrapped_equal(_fe_cur, _fe_end, v.end());
                ++foreach_detail::unwrap(_fe_cur, v.end()))
                    if(i=*foreach_detail::unwrap(_fe_cur, v.end()), true)  // тут if а не for
    {
        if(i==2) break;
        s+=i;
    }

    std::cout <<s;
    return 0;
}

Dim i as Integer
For Each i in col
' ...
Next

int i;
foreach(i, vec) s+=i;

f:\...xxx.cpp(24) : error C2667: 'foreach_detail::begin' : none of 2 overloads have a best conversion
f:\Work\prg\unnamed\include\0-utility\lang\foreach.h(281): could be 'foreach_detail::wrapper<boost::range_const_iterator<Range>::type> foreach_detail::begin(const Range &)'
f:\Work\prg\unnamed\include\0-utility\lang\foreach.h(274): or 'foreach_detail::wrapper<boost::range_iterator<Range>::type> foreach_detail::begin(Range &)'
while trying to match the argument list '(const std::list<_Ty,_Ax>)'
with
[
_Ty=Phoenix::PBoundedObject,
_Ax=std::allocator<Phoenix::PBoundedObject>
]

template<class Range>
wrapper<typename boost::range_iterator<Range>::type>
    begin( Range& range )
{
    return boost::begin( range );
}

template<class Range>
wrapper<typename boost::range_const_iterator<Range>::type>
    begin(Range const& range )
{
    return boost::begin( range );
}

const list<PBoundedObject>& objects;
foreach (const PBoundedObject& i, objects)

F>#define FOR_EACH( ElementDecl, Range )\
F>    if( bool _fe_break = false ) {}\
F>    else\
F>    for( foreach_detail::holder const\
F>              &_fe_current = foreach_detail::begin(Range)\
F>            , &_fe_last    = foreach_detail::end(Range)\

F>        ; ++_fe_current(Range)\
F>    )\
F>    for( ElementDecl = *_fe_current(Range); _fe_break; _fe_break = false )\
F>// end macro

foreach (int& i, obj->ints) {
    obj=NULL;
    break;
}

template <class T>
inline common_ptr<T> BNamespace::Find(const string& name) const {
    BOOST_FOREACH (PEntity i, this->contents)
    // BOOST_FOREACH (const PEntity& i, this->contents) глючит точно также
        if (i->GetName()==name) {
            if (i->GetType()==T::Type)
                return static_pointer_cast<T>(i);
            else
                return NULL;
        }

    return NULL;
}