C++ 中函数模板的返回类型作为第二个模板参数

Question

如何实现下面的模板？

std::result_of不是这样工作的。

我希望能够通过其他外部方式更改std::vector

我想在我的模板中保留F和V作为第一个

最好在 C++17 中

谢谢

template <typename F, typename V=vector<result_of<F>>, typename T, typename Ts ...>
auto call (F f, const T & t, const Ts & ... ts) {
  V v;  //  v is a container for values returned from f
  f(....);  // f is a funtion
  ....
  return v;
}

Answer 1

据我了解，您希望根据函数的返回类型提供一个默认模板参数，而无需函数参数类型。 我不知道有什么好方法可以做到这一点，但是这个 hack 似乎可以解决您的问题

template <typename F, typename V=bool, typename T, typename... Ts>
auto call(F f, const T& t, const Ts&... ts) {
      using Container = typename std::conditional<std::is_same<bool,
      V>::value,
      std::vector<decltype(f(/*... whatever the args are*/))>,
      V>::type;

      Container c;
     // do stuff...
     return c;
}

Answer 2

不确定你想要什么......

但我想是这样的

template <template <typename...> class C = std::vector,
          typename F, typename T, typename ... Ts>
auto call (F f, const T & t, const Ts & ... ts)
 {
   C<decltype(f(t))> v;

   (v.emplace_back(t), ..., v.emplace_back(ts));

   return v;
}

其中容器类型是第一个模板参数，默认为std::vector 。

所以你可以打电话

auto cv = call<std::vector>(foo, '0', '1', '2', '3');

或者也

auto cv = call(foo, '0', '1', '2', '3');

但我看到的真正问题是：如何在容器中插入元素？

我使用过emplace_back() ，在考虑std::vector ； 但是如果你想通过（例如） std::set ，你不会找到emplace_back()而是emplace_back() emplace() 。 那么您是否还想将插入方法作为模板参数传递？

无论如何，以下是一个完整的工作示例

#include <vector>
#include <iostream>

template <template <typename...> class C = std::vector,
          typename F, typename T, typename ... Ts>
auto call (F f, const T & t, const Ts & ... ts)
 {
   C<decltype(f(t))> v;

   (v.emplace_back(t), ..., v.emplace_back(ts));

   return v;
}

int foo (char ch)
 { return ch; }

int main()
 {
   auto cv = call(foo, '0', '1', '2', '3');

   for ( auto const & i : cv )
      std::cout << i << ' ';

   std::cout << std::endl;
 }

Answer 3

最后我得到了这个

template <typename Rt = void, typename F, typename T, typename... Ts>
      auto mapf(F f, const T & t, const Ts & ... ts) {
          auto m = minsize(t, ts...);
          using Vt = decltype(std::forward<F>(f)(*begin(t), *begin(ts)...));
          using V = typename std::conditional<is_same<Rt,void>::value, vector<Vt>, Rt>::type;
          V r;                                                                                                                                                                                                                                                               
          r.resize(m);
          for(auto i = 0u; i < m; i++) {
              auto tuples =  make_tuple(*next(begin(t),i), *next(begin(ts),i)...);
             auto v = apply<tuple<typename T::value_type, typename Ts::value_type ...>>(tuples, forward<F>(f));
              *next(begin(r),i) = move(v);
          }    
          return r;
      }