Nathan Ridge wrote:
This effectively means that the "Valid Expressions" for SinglePassRange part of the documenation should read:
a.begin() a.end()
Doesn't it. I would be interested to know if I got this wrong.
Nope.
Suppose I have a third-party library with a class named Vector which has methods named Begin() and End() rather than begin() and end(). I can't change Vector, but I'd still like to use it as a SinglePassRange. Boost.Range allows me to do that, by overloading range_begin() and range_end() in the namespace of Vector (so that boost::begin() and boost::end() finds them by ADL) as described in [1].
namespace namespace_of_Vector { Vector::Iterator range_begin(Vector& v) { return v.Begin(); } Vector::Iterator range_end(Vector& v) { return v.End(); } // overloads for const Vector& }
Now if v is of type Vector, boost::begin(v) and boost::end(v) will be valid expressions, but v.begin() and v.end() will not.
Of course you can do this. But looking at the documenation you wouldn't expect copy(std::vector<int>, 0) to compile without error. In fact, looking at the documentation you would conclude that you have to do this - when in fact you don't. The concept classes of Boost.Range test success for something like vector<int> which suggests that a container is a range. Although it's technically correct within the confines of boost.range - it's extremely unintuitive and confusing. For example, it's not at all obvious int x[10] boost::find(x, 0); should compile or not.
So this extra layer allows us to adapt third-party types that we have no control over to model Boost.Range concepts such as SinglePassRange.
I can see that by looking at the implementation but it's not clear from looking at the documentation. The fact that there is an extra layer is sort of hidden from the person using the library.
b) I see the template iterator_range<ForwardTraversalIterator> -
which seem to be to in an instance of what the ForwardRangeConcept should be.
I'm not sure I understand what the question/problem here is. Could you elaborate?
It just illustrates the source of the confusion. iterator_range<ForwardTraversalIterator> is a direct implementation of ForwardTransversalRange> and sort of what I exect to see. It's not clear how a std::vector gets "transformed" - (Please don't explain it to me, I've seen how it works). This intermediate transformation goes directly from vector->ForwardTransversalRange without passing through and interator_range. It's all very confusing, an unintuitive which makes it much harder to figure out how to use it than it should be. d) I forgot to add this. The exposition of each function, template etc, could benefit by including a small example. This is common practice among other similar libraries. It is generally very helpful. Robert Ramey
_______________________________________________ Boost-users mailing list Boost-users@lists.boost.org http://lists.boost.org/mailman/listinfo.cgi/boost-users