Boost C++ Libraries: Ticket #1295: for each in VC8+

status changed; resolution set

Eric Niebler — Wed, 03 Oct 2007 11:10:27 GMT

status new → closed
resolution → wontfix

Can't be done. MSVC 'for each' can't operate on native array types, iterator ranges or C strings nor is extensible via Boost.Range customization points. 'for each' also cannot iterate over an STL container using a non-const reference iteration variable.

Nobody has complained about compile times with BOOST_FOREACH.

NN — Fri, 19 Oct 2007 16:54:25 GMT

VC can iterate over native array and iterator ranges. In VC9 you can iterate over string literals too.

There is no option to change variables, but this can be easily fixed with const_cast.

This what you can do with VC9 for each:

#include <boost/array.hpp>
#include <boost/range/iterator_range.hpp>
#include <vector>
template<typename T, size_t N>
boost::array<T, N> make_array_range()
{
    boost::array<T, N> a;
    T c = 0;
    for each(T const& i in a)
        const_cast<T&>(i) = c++;
    return a;
}
int main()
{
    for each(int i in make_array_range<int, 10>())
        printf("%d", i);
    typedef boost::array<int, 10> ints;
    ints a = make_array_range<int, 10>();
    boost::iterator_range<ints::iterator> x(a.begin(), a.end());
    for each(ints::const_reference i in x)
        printf("%d", i);
    for each(char% c in "asdf")
        printf("%c", c);
    typedef std::vector<int> vints;
    vints v(a.begin(), a.end());
    for each(vints::const_reference i in v)
        const_cast<vints::reference>(i) = 0;
}

Of course this is not full replacement of Boost.Foreach.

status changed; resolution deleted

NN — Fri, 19 Oct 2007 21:07:02 GMT

status closed → reopened
resolution wontfix

I have found the way to make it work with all requirements:

#include <boost/range/iterator_range.hpp>
#include <boost/foreach.hpp>
#if defined(_MSC_VER) && _MSC_VER >= 1400 // VC 8.0+   
    #define foreach(var, col) \
        for each(var in (::boost::make_iterator_range(col)))
#else // Other compilers
    #define foreach BOOST_FOREACH
#endif  // defined(_MSC_VER) && _MSC_VER >= 1400 // VC 8.0+

There is a code for test:

#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/array.hpp>
#include <boost/lambda/lambda.hpp>
#include <vector>
#include <cassert>
#include <iostream>
#include <iterator>
namespace my
{
// Extensibility check
struct non_iteratable
{
    non_iteratable()
    {
        x[0] = 0;
        x[1] = 1;
    }
    typedef boost::array<int, 2> x_type;
    x_type x;
};
non_iteratable::x_type::iterator boost_range_begin(non_iteratable& c)
{
    return boost::begin(c.x);
}
non_iteratable::x_type::iterator boost_range_end(non_iteratable& c)
{
    return boost::end(c.x);
}
non_iteratable::x_type::const_iterator boost_range_begin(non_iteratable const& c)
{
    return boost::begin(c.x);
}
non_iteratable::x_type::const_iterator boost_range_end(non_iteratable const& c)
{
    return boost::end(c.x);
}
} // namespace my
namespace boost
{
// specialize rannge_iterator and range_const_iterator in namespace boost
template<>
struct range_iterator<my::non_iteratable>
{
    typedef my::non_iteratable::x_type::iterator type;
};
template<>
struct range_const_iterator<my::non_iteratable>
{
    typedef my::non_iteratable::x_type::const_iterator type;
};
} // namespace boost
int main()
{
    {
    // Regular array
    int a[10] = {};
    // Value
    foreach(int i, a)
        std::cout << i;
    // Reference to const
    foreach(int const& i, a)
        std::cout << i;
    // Reference to non Const
    foreach(int& i, a)
        i = 1;
    assert(std::find(boost::begin(a), boost::end(a), 0) == boost::end(a));
    }
    {
    // Boost.Array
    boost::array<int, 10> a = {};
    // Value
    foreach(int i, a)
        std::cout << i;
    // Reference to const
    foreach(int const& i, a)
        std::cout << i;
    // Reference to non Const
    foreach(int& i, a)
        i = 1;
    assert(std::find(boost::begin(a), boost::end(a), 0) == boost::end(a));
    }
    {
    // Std.Vector
    std::vector<int> a(10);
    // Value
    foreach(int i, a)
        std::cout << i;
    // Reference to const
    foreach(int const& i, a)
        std::cout << i;
    // Reference to non Const
    foreach(int& i, a)
        i = 1;
    assert(std::find(boost::begin(a), boost::end(a), 0) == boost::end(a));
    }
    // Extensibility
    {
    my::non_iteratable a;
    // Value
    foreach(int i, a)
        std::cout << i;
    // Reference to const
    foreach(int const& i, a)
        std::cout << i;
    // Reference to non Const
    foreach(int& i, a)
        i = 1;
    assert(std::find(boost::begin(a), boost::end(a), 0) == boost::end(a));
    }
}

The code works as expected. Thank you for attention.

status changed; resolution set

Eric Niebler — Tue, 04 Mar 2008 23:15:34 GMT

status reopened → closed
resolution → wontfix

Sorry, no. If you try replacing the BOOST_FOREACH macro as you suggest and run the foreach regression tests, you'll see that this does not handle rvalue collections correctly. Besides, BOOST_FOREACH has well-defined customization hooks, which this implementation is not respecting. There is simply no way.

NN — Mon, 07 Apr 2008 12:35:15 GMT

Thanx, I will check the regression tests.

NN — Sat, 12 Apr 2008 15:43:27 GMT

Here: http://rsdn.ru/forum/message/2907464.1.aspx I have some for each implementation. It does not passes rvalue.

But the code is more optimized than BOOST_FOREACH.

anonymous — Sat, 12 Apr 2008 15:51:12 GMT

I'll look at it once you get it to pass all of the regression tests.