Generic way to access elements of sequential sequences - c++

Question

What is the best way to write generic code for targeting C arrays, C++ libraries, and C++ standard library?
Example: dot product
template<class Vector1, class Vector2>
constexpr auto dot_product(Vector1 const& v1, Vector2 const& v2) {
// doesn't work for Vectors that do not implement () subscripting
using return_type = decltype(v1(0) + v2(0));
return_type tmp = return_type{};
// doesn't work for e.g. std::tuple
for (std::size_t i = 0, e = size(v1); i != e; ++i) {
tmp += v1(i) * v2(i);
}
return tmp;
}
There is a problem with access the elements:
for a C array array[i], C matrix array[i][j]
for a C++ std::vector, vector[i]
for a C++ tuple, std::get<i>(tuple)
for a C++ linear algebra vector/matrix (e.g. Eigen): vector(i), matrix(i, j)
There is a problem with iteration:
run-time for loops for C arrays, std::vectors, ...
boost::fusion for e.g. std::array, std::tuple, ...
custom expression for linear algebra libraries that handle both cases under the covers (e.g. Eigen uses expression templates)
Boost.Geometry uses a get function to solve the access problem which results in convoluted code full with gets everywhere. It also uses strategies for dispatching the different iteration methods.
Are there any better alternatives?

Answer 1

You can work with policy based template.
template <typename T>
struct DefaultUsePolicy {
int DoSomethingWithT( T const & ) {
return 42;
}
};
template < typename T, typename UsePolicy = DefaultUsePolicy<T>>
int Generic( T& arg ) {
UsePolicy use;
return use.DoSomethingWithT(arg);
}
Then have some default implementation for common type and let the user write a policy if he have a custom type.
The Generic function will document the services need in the policies it requires.
It is similar to what is done with std::unique_ptr and std::default_deleter to provide control on the destruction of the pointer owned.

Answer 2

You may wrap the get function inside a class, something like:
#define Return(ret) decltype ret { return ret; }
template <typename T>
class Getter
{
private:
T& t;
public:
constexpr explicit Getter(T&t) : t(t) {}
constexpr auto operator () (std::size_t i) const
-> Return((get(t, i)))
constexpr auto operator () (std::size_t i, std::size_t j) const
-> Return((get(t, i, j)))
operator T&() const { return t; }
};
template <typename T>
Getter<T> make_getter(T&t) { return Getter<T>(t); }
And then
template<class Vector1, class Vector2>
constexpr auto dot_product(Vector1 const& v1_arg, Vector2 const& v2_arg) {
auto v1 = make_getter(v1_arg);
auto v2 = make_getter(v2_arg);
using return_type = decltype(v1(0) + v2(0));
return_type tmp = return_type{};
for (std::size_t i = 0, e = size(v1); i != e; ++i) {
tmp += v1(i) * v2(i);
}
return tmp;
}