There are a number of different ways, that make a type/class usable in a ranged for loop. An overview is for example given on cppreference:
range-expression
is evaluated to determine the sequence or range to iterate. Each element of the sequence, in turn, is dereferenced and is used to initialize the variable with the type and name given in range-declaration.
begin_expr
andend_expr
are defined as follows:
- If
range-expression
is an expression of array type, thenbegin_expr
is__range
andend_expr
is (__range
+__bound
), where__bound
is the number of elements in the array (if the array has unknown size or is of an incomplete type, the program is ill-formed)- If
range-expression
is an expression of a class typeC
that has both a member namedbegin
and a member namedend
(regardless of the type or accessibility of such member), thenbegin_expr
is__range.begin()
andend_expr
is__range.end()
- Otherwise,
begin_expr
isbegin(__range)
andend_expr
isend(__range)
, which are found via argument-dependent lookup (non-ADL lookup is not performed).
If I want to use a ranged for loop say in a function template, I want to constrain the type to be usable in a ranged for loop, to trigger a compiler error with a nice "constraint not satisfied" message. Consider the following example:
template<typename T>
requires requires (T arg) {
// what to write here ??
}
void f(T arg) {
for ( auto e : arg ) {
}
}
Obviously for a generic function I want to support all of the above listed ways, that a type can use to make itself ranged for compatible.
This brings me to my questions:
- Is there a better way than manually combining all the different ways into a custom concept, is there some standard library concept that I can use for that? In the concepts library, there is no such thing. And if there is really no such thing, is there a reason for that?
- If there is no library/builtin concept for that, how am I supposed to implement such
thing. What really puzzles me, is how to test for members
begin
andend
regardless of the type or accessibility of such member (second bullet in the qouted list). A requires clause that tests for example for the existence of abegin()
member fails ifbegin()
is private, but the ranged for loop would be able to use the type regardless of that.
Note I am aware of the following two questions:
- What concept allows a container to be usable in a range-based for loop?
- How to make my custom type to work with "range-based for loops"?
but neither of them really answers my question.
It seems like what you need is
std::ranges::range
which requires the expressionsranges::begin(t)
andranges::end(t)
to be well-formed.Where
ranges::begin
is defined in [range.access.begin]:That is to say, it will not only perform specific operations on the array type but also decide whether to invoke member function
range.begin()
or free functionbegin(range)
based on the validity of the expression, this already covers the behavior described by the so-called range-expression. Andranges::end
follows similar rules. So I think you can simply doIt should be noted that
ranges::begin
requires that the returned type must modelinput_or_output_iterator
, andranges::end
also requires that the returned type must modelsentinel_for
type returned byranges::begin
, so thatT
is enough to be arange
. The range-expression does not have such constraints, it only checks the validity of the expression, so a minimal type that can use a range-based for loop could beBut I don't think you're interested in such a case since
I
is not sufficient to constitute a valid iterator.