Iterating over vectors in a parameter pack

user_13185261 0
Viewed 185

I have a function that takes in a parameter pack of vectors, These vectors will be of the same length, and I want to call a function with the values of both of these vectors at each index.

For example I pass in a function which prints out two integers that I pass in. I would put in two vectors of integers to the function, and it will call the function I pass in for each of the indexes, The code may help explain what i want to do

#include <iostream>
#include <thread>
#include <functional>
#include <vector>

template<
    typename RETURN,
    typename ... INPUTS
>
std::vector<RETURN> thread_transform(std::function<RETURN(INPUTS ...)> function, std::vector<INPUTS>& ... inputs)
{
    std::cout << __PRETTY_FUNCTION__ << std::endl;
    /* Code to loop over the vectors in 'inputs' and call 'function' with */
}

int func(int a, int b)
{
    std::cout << a << ' ' << b << std::endl;
}

int main(int argc, char** argv)
{
    std::vector<int> a;
    std::vector<int> b;
    std::vector<int> ret = thread_transform(std::function<int(int, int)>(func), a, b);
    return 0;
}
variadic-templates vector templates function c++
2 Answers

Something along these lines, perhaps:

template<typename RETURN, typename ... INPUTS>
std::vector<RETURN> thread_transform(
    std::function<RETURN(INPUTS ...)> function,
    std::vector<INPUTS>& ... inputs)
{
    std::vector<RETURN> ret;
    auto size = std::min({inputs.size()...});
    for (int i = 0; i < size; ++i) {
        ret.push_back(function(inputs[i]...));
    }
    return ret;
}

Pretty straightforward. Demo

user_16701290

I'd suggest simplifying the signature of the function, and not hardcoding for vectors or std::function.

Since you're already defining a function template, you might as well accept any ranges and any calleable:

Live On Compiler Explorer

template <typename F, typename... Rs>
auto zip(F f, Rs const&... args) {
    using R = std::decay_t<
        std::invoke_result_t<F, typename Rs::value_type...>
    >;
    auto const n = std::min({args.size()...});
    std::vector<R> r(n);
    for (size_t i = 0; i<n; ++i)
        r[i] = f(args[i]...);
    return r;
}

In fact, when you generalize, you will end up with RangeV3's zip_with:

template <typename F, typename... Rs>
auto my_zip(F&& f, Rs const&... args) {
    return r::to_vector(v::zip_with(f, args...));
}

I would argue you can do without the to_vector by default.

Live On Compiler Explorer

#include <fmt/ranges.h>
#include <functional>
#include <iostream>
#include <map>
#include <range/v3/all.hpp>
#include <vector>

namespace r = ::ranges;
namespace v = r::views;
using namespace std::string_literals;

template <typename F, typename... Rs>
auto zip(F f, Rs const&... args) {
    return v::zip_with(std::move(f), args...);
}

template <typename F, typename... Rs>
auto zip_vec(F const& f, Rs const&... args) {
    return r::to_vector(zip(f, args...));
}

auto foo(int x, std::string_view s) {
    std::string r(s.size() * x, '\0');
    while (x--) {
        std::copy(s.begin(), s.end(), r.begin() + x * s.size());
    }
    return r;
}

int main() {
    std::vector<int> a{ 1, 3 }, b{ 2, -2 };

    auto mul = std::multiplies<>{};
    fmt::print("{} x {} -> {}\n", a, b, zip(mul, a, b));

    auto ret = zip_vec(std::plus<>{}, a, b);
    fmt::print("ret as a vector: {}\n", ret);
    static_assert(std::is_same_v<decltype(ret), std::vector<int>>);

    std::map<std::string, int> m { {"one"s, 1}, {"three"s, 3} };
    fmt::print("But also using a non-vectors: {}\nor {}\n",
    zip(foo, a, m | v::keys),
    zip(mul, a, m | v::values));
}

Prints

{1, 3} x {2, -2} -> {2, -6}
ret as a vector: {3, 1}
But also using a non-vectors: {"one", "threethreethree"}
or {1, 9}
user_853710
Related