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