The concepts-lite extension for c++ is accepted for the upcoming C++17 standard. Some tutorials are already available and with the current gcc trunk an experimental implementation of this feature in a c++ compiler. We will see some examples of concepts-lite in action.
The task is to write a library that overloads to
operator* in order to scale an
iterable object by a scalar factor, e.g. scale a vector by a double value. In
order to be very generic, we want to write a templated function for the scaling:
This implementation provides a scaling of a vector by a scalar factor from the right. The problem with this implementation is, that we can not distiguish between the vector argument and the scalar argument, since both are unconstrained templates. Passing a scalar as first argument and a vector as second argument is a valid call to the function, but results in a compiler error in the inner algorithm, i.e. in the range-based for-loop, since a scalar is not iterable.
It is possible to write an overload of
operator* for a left-sided multiplication
by using tag-dispatiching, SFINAE techniques, or some other tricks. But we want
to write the code in a natural way. Therefore, we use constraints by the concepts-lite
specification (Technical specification, Tutorial).
What is a vector? Or at least an iterable object? We require, that a range-based
for-loop can be used for the container, i.e. there exist
(member) functions and the current iterate, i.e. the value-type of a vector, is
multiplicable by a scalar.
What is a scalar, on the other hand? For now we simply require, that it is an
arithmetic type, that fulfills the type-trait
we can refine this concept, by explicitly specifying requirements on scalar arguments.
In order to use type-constraints, we have to define concepts:
The first one (Iterable) provides a simplified concept for iterable objects, i.e.
there must exist either a free function
end() or member functions
with the same names. Here, nothing is said about what these functions should return.
A more advanced implementation could be a requirement that the result of
end() are Iterators (Input- or Output-Iterators, depending on other requirements).
The second concepts simply redirects to the type-traits implementation of the STL.
The third concepts is a binary concept, since it implements a relation between two
types. Here, we just require, that a multiplication operation between these two types
Combined with the operator definition above, we can now define
scalar*vector concept-enabled function overloads:
Value_type is an alias template leading to the value type of a container.
A possible implementation could be:
So, we can now multiply any iterable object by any arithmetic type, if the value-types are multiplicable, e.g.
You can download the source of the final implementation from here.