C++17前实现std::apply

最新推荐文章于 2023-12-07 15:21:08 发布
最新推荐文章于 2023-12-07 15:21:08 发布
阅读量284 收藏
点赞数
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_67275689/article/details/130442862
版权

C++17中加入的std::apply可以将让我们直接将元组拆包将元组中的成员直接转发给目标函数, 比如

#include <iostream>
#include <utility>
#include <tuple>

void func(int i, char c, std::string str) {
    std::cout << i << ", " << c << ", " << str << std::endl;
}

int main() {
    auto args = std::make_tuple(1, 'A', std::string{"hello"});
    //args类型为 std::tuple<int, char, std::string>
    std::apply(func, args); // 使用C++17标准的apply
    return 0;
}

关于std::apply的详细介绍和用法可以参考

​​​​​​ std::apply - cppreference.comicon-default.png?t=N3I4https://zh.cppreference.com/w/cpp/utility/apply如果我想在C++17之前使用的话, 就需要自己实现一个; 我们可以知道元组可以使用std::get访问其成员, 比如

#include <iostream>
#include <utility>
#include <tuple>

int main() {
    auto t = std::make_tuple(1, "hello", 3.14f);
    /*1) 通过下标访问*/
    std::get<0>(t); //获取元组第一个成员1
    std::get<2>(t); //获取元组第三个成员3.14f
    /*2) 通过类型访问*/
    std::get<float>(t); //获取元组类型为float的成员
    //不过需要注意的是: 如果元组有多个同类型的成员, 不能通过类型访问, 以下代码错误
    //std::tuple<int, int, const char*> t1{123, 456, "world"};
    //std::get<int>(t1); //由于元组第一个成员和第二个成员都是int
    return 0;
}

关于std::get的详细介绍即用法, 可以参考

std::get(std::tuple) - cppreference.comicon-default.png?t=N3I4https://zh.cppreference.com/w/cpp/utility/tuple/get所以我可以使用std::get通过下标访问成员, 将元组成员传参给函数

#include <iostream>
#include <utility>
#include <tuple>

void func(int i1, int i2, std::string str) {
    std::cout << i1 << ", " << i2<< ", " << str << '\n';
}

int main() {
    auto t = std::make_tuple(1, 2, std::string{"hhh"});
    func(std::get<0>(t), std::get<1>(t), std::get<2>(t));
    return 0;
}

当然我们要进一步抽象这个过程(毕竟我们要实现的apply是一个不管元组有多少成员都可以使用的)

#include <iostream>
#include <utility>
#include <tuple>

template<size_t... Indexes, typename Func, typename Tuple>
void apply(Func&& f, Tuple&& t) {
    // 此处Tuple&&为万能引用, 毕竟我们应该允许传入值类别为右值的元组
    f(std::get<Indexes>(std::forward<Tuple>(t))...);
    /*
        get时也应该对t进行转发, 毕竟get对值类别为左值的元组和对右值的处理不同, 
        有兴趣自己可以看看其实现, 不在此赘述
    */
}

void func(int i1, int i2, std::string str) {
    std::cout << i1 << ", " << i2 << ", " << str << '\n';
}

int main() {
    auto t = std::make_tuple(1, 2, std::string{"hhh"});
    apply<0, 1, 2>(func, t);
    return 0;
}

我们可以借助非类型形参包, 来抽象这一过程, 关于非类型形参包的介绍与使用可参考

形参包 (C++11 起) - cppreference.comicon-default.png?t=N3I4https://zh.cppreference.com/w/cpp/language/parameter_pack但是可以看到下标仍需要我们自己传入, 那么有没有办法根据元组的大小(假设为n)生成0, 1, ..., n-1这样的序列呢?

有! 那就是C++14中的std::make_index_sequence及std::make_integer_sequence

std::integer_sequence - cppreference.comicon-default.png?t=N3I4https://zh.cppreference.com/w/cpp/utility/integer_sequencestd::make_index_sequence<N>() 可以生成std::integer_sequence<size_t, 0, 1, 2, ..., N-1>

我们只要萃取到index_sequence(integer_sequence<size_t>的别名)中的数字就行了

#include <iostream>
#include <tuple>
#include <utility>


template<size_t... Indexes, typename Func, typename Tuple>
void apply_impl(Func&& f, Tuple&& t, std::index_sequence<Indexes...>) {
    f(std::get<Indexes>(std::forward<Tuple>(t))...);
}

template<typename Func, typename Tuple>
void apply(Func&& f, Tuple&& t) {
    apply_impl(std::forward<Func>(f), std::forward<Tuple>(t), std::make_index_sequence<std::tuple_size<typename std::remove_reference<Tuple>::type>::value>());
    //可以使用std::tuple_size获取元组的大小, 获取大小之前先要remove_reference, 因为Tuple可能被推断为std::tuple<...>&
}

void func(int i1, int i2, std::string str) {
    std::cout << i1 << ", " << i2 << ", " << str << '\n';
}

int main() {
    auto t = std::make_tuple(1, 2, std::string{"hhh"});
    apply(func, t);
    return 0;
}

就这样自动拆包传参的问题就解决了。现在我们还想获取func的返回值, 可以使用C++14中的decltype(auto)它能自动推断返回值类型(其实auto(auto&, auto&&)等也可以推断, 但由于它们本身推导规则的原因(比如出现类型退化), 不能准确推导函数的返回值类型;

关于decltype(auto)及auto, auto&, auto&&的推导规则:

占位类型说明符 (C++11 起) - cppreference.comicon-default.png?t=N3I4https://zh.cppreference.com/w/cpp/language/auto

#include <iostream>
#include <tuple>
#include <utility>


template<size_t... Indexes, typename Func, typename Tuple>
decltype(auto) apply_impl(Func&& f, Tuple&& t, std::index_sequence<Indexes...>) {
    return f(std::get<Indexes>(std::forward<Tuple>(t))...);
}

template<typename Func, typename Tuple>
decltype(auto) apply(Func&& f, Tuple&& t) {
    return apply_impl(std::forward<Func>(f), std::forward<Tuple>(t), std::make_index_sequence<std::tuple_size<typename std::remove_reference<Tuple>::type>::value>());
}

int func(int i1, int i2, std::string str) {
    std::cout << i1 << ", " << i2 << ", " << str << '\n';
    return 123;
}

int main() {
    auto t = std::make_tuple(1, 2, std::string{"hhh"});
    auto res = apply(func, t);
    std::cout << "`func` return " << res << '\n';
    return 0;
}

现在我们的apply可以再C++14的环境中使用了, 但不能在C++11的环境中使用, 因为integer_sequence以及decltype(auto)都是C++14后才有的

我们如何在C++11中实现呢?

其实make_index_sequence我们可以自己实现, 至于目标函数返回值类型我们也有办法(通过后置返回值以及decltype)获取。

实现make_index_sequence:

template<size_t N, size_t... Rests>
struct make_index_seq : make_index_seq<N-1, N, Rests...> {};

template<size_t... Rests>
struct make_index_seq<0, Rests...> {
    using result = make_index_seq<0, Rests...>;    
};

对于上述代码的解释: 假设传入一个数字n:

make_index_seq<n>继承自make_index_seq<n-1, n>,

make_index_seq<n-1, n>继承自make_index_seq<n-2, n-1, n>,

make_index_seq<n-2, n-1, n>继承自make_index_seq<n-3, n-2, n-1, n>,

......

make_index_seq<1, 2, ..., n>继承自make_index_seq<0, 1, 2, ..., n>

由类成员名字查找的规则(自己的类定义中查找不到成员, 会去基类中查找), make_index_seq<n>::result会查找到make_index_seq<0, 1, 2, 3, ..., n>的result

而make_index_seq<0, 1, 2, .., n>的成员result是自身的别名, 也就是说make_index_seq<n>::result就会得到make_index_seq<0, 1, 2, ..., n>

假设一个元祖的大小为m, 我们传入m-1给make_index_seq是, 就会得到make_index_seq<0, 1, 2, 3, ..., m-1>, 我们对make_index_seq进行萃取就能得到0, 1, 2, ..., m-1

#include <iostream>
#include <tuple>
#include <utility>

template<size_t N, size_t... Rests>
struct make_index_seq : make_index_seq<N-1, N, Rests...> {};

template<size_t... Rests>
struct make_index_seq<0, Rests...> {
    using result = make_index_seq<0, Rests...>;    
};

template<size_t... Indexes, typename Func, typename Tuple>
decltype(auto) apply_impl(Func&& f, Tuple&& t, make_index_seq<Indexes...>) {
    return f(std::get<Indexes>(std::forward<Tuple>(t))...);
}

template<typename Func, typename Tuple>
decltype(auto) apply(Func&& f, Tuple&& t) {
    return apply_impl(std::forward<Func>(f), std::forward<Tuple>(t), typename make_index_seq<std::tuple_size<typename std::remove_reference<Tuple>::type>::value - 1>::result());
}

int func(int i1, int i2, std::string str) {
    std::cout << i1 << ", " << i2 << ", " << str << '\n';
    return 123;
}

int main() {
    auto t = std::make_tuple(1, 2, std::string{"hhh"});
    auto res = apply(func, t);
    std::cout << "`func` return " << res << '\n';
    return 0;
}

最后就差替换掉decltype(auto), 就能在C++11中使用了。我们想要的是func的返回值类型是什么, apply的返回值类型就是什么，而后置返回值+decltype(func(...))可以获取返回值的类型, 见

C++ Trailing Return Types ‐ Daniel Siegericon-default.png?t=N3I4https://www.danielsieger.com/blog/2022/01/28/cpp-trailing-return-types.html

#include <iostream>
#include <tuple>
#include <utility>

template<size_t N, size_t... Rests>
struct make_index_seq : make_index_seq<N - 1, N, Rests...> {};

template<size_t... Rests>
struct make_index_seq<0, Rests...> {
    using result = make_index_seq<0, Rests...>;
};

template<size_t... Indexes, typename Func, typename Tuple>
auto apply_impl(Func&& f, Tuple&& t, make_index_seq<Indexes...>)
        -> decltype(f(std::get<Indexes>(std::forward<Tuple>(t))...))

{
    return f(std::get<Indexes>(std::forward<Tuple>(t))...);
}

template<typename Func, typename Tuple>
auto apply(Func&& f, Tuple&& t)
        -> decltype(apply_impl(std::forward<Func>(f), std::forward<Tuple>(t), typename make_index_seq<std::tuple_size<typename std::remove_reference<Tuple>::type>::value - 1>::result()))
{
    return apply_impl(std::forward<Func>(f), std::forward<Tuple>(t), typename make_index_seq<std::tuple_size<typename std::remove_reference<Tuple>::type>::value - 1>::result());
}

int func(int i1, int i2, std::string str) {
    std::cout << i1 << ", " << i2 << ", " << str << '\n';
    return 123;
}

int main() {
    auto t = std::make_tuple(1, 2, std::string{"hhh"});
    auto res = apply(func, t);
    std::cout << "`func` return " << res << '\n';
    return 0;
}

由于decltype中是不求值语境(只获取编译时的信息, 如类型), 所以decltype(...)中的函数不会被调用。最后需要注意的是由于tuple属于namespace std, 根据ADL(实参依赖查找)会找到std::apply, 所以我们的这个apply在C++17以后会与std::apply发生冲突, 所以最好将自己实现的apply改成别的函数名, 或者加入到别的名称空间,反正最好别放在全局空间。 

#include <tuple>
#include <utility>

template<size_t N, size_t... Rests>
struct make_index_seq : make_index_seq<N - 1, N, Rests...> {};

template<size_t... Rests>
struct make_index_seq<0, Rests...> {
    using result = make_index_seq<0, Rests...>;
};

template<size_t... Indexes, typename Func, typename Tuple>
auto my_apply_impl(Func&& f, Tuple&& t, make_index_seq<Indexes...>)
        -> decltype(f(std::get<Indexes>(std::forward<Tuple>(t))...))

{
    return f(std::get<Indexes>(std::forward<Tuple>(t))...);
}

template<typename Func, typename Tuple>
auto my_apply(Func&& f, Tuple&& t)
        -> decltype(my_apply_impl(std::forward<Func>(f), std::forward<Tuple>(t), typename make_index_seq<std::tuple_size<typename std::remove_reference<Tuple>::type>::value - 1>::result()))
{
    return my_apply_impl(std::forward<Func>(f), std::forward<Tuple>(t), typename make_index_seq<std::tuple_size<typename std::remove_reference<Tuple>::type>::value - 1>::result());
}

还有就是我们自己实现的这个apply不能直接传入函数模板名(即便是std::apply也不能使用), 当然你可以自己再通过形参包自己包装一个能够判断模板的, 我这里就不展开讲了

测试:

Compiler Explorertemplate<size_t N, size_t... Rests>struct make_index_seq : make_index_seq<N - 1, N, Rests...> {};template<size_t... Rests>struct make_index_seq<0, Rests...> { using result = make_index_seq<0, Rests...>;};template<size_t... Indexes, typename Func, typename Tuple>auto my_apply_impl(Func&& f, Tuple&& t, make_index_seq<Indexes...>) -> decltype(f(std::get<Indexes>(std::forward<Tuple>(t))...)){ return f(std::get<Indexes>(std::forward<Tuple>(t))...);}template<typename Func, typename Tuple>auto my_apply(Func&& f, Tuple&& t) -> decltype(my_apply_impl(std::forward<Func>(f), std::forward<Tuple>(t), typename make_index_seq<std::tuple_size<typename std::remove_reference<Tuple>::type>::value - 1>::result())){ return my_apply_impl(std::forward<Func>(f), std::forward<Tuple>(t), typename make_index_seq<std::tuple_size<typename std::remove_reference<Tuple>::type>::value - 1>::result());}template<size_t S, typename T = int>auto f1(T t1, T t2, T t3) -> T* { static T arr[S]{t1, t2, t3}; return arr;}std::string f2(char c, size_t num) { return std::string(num, c);}std::string f3(std::string& s1, std::string& s2) { return s1 + s2;}struct Functor1 { int operator() (int i, int j) { return i + j; }};struct Functor2 { int operator() (Functor1 f11, Functor1 f12, int a, int b, int c, int d) { return f11(a, b) + f12(c, d); };};int main() { int* p = my_apply(f1<3>, std::make_tuple(123, 456, 789)); std::cout << p[0] << ", " << p[1] << ", " << p[2] << '\n'; std::cout << my_apply(f2, std::make_tuple('A', 10)) << '\n'; auto t = std::make_tuple(std::string{"hello "}, std::string{"world"}); std::cout << my_apply(f3, t) << '\n'; int s; auto&& lambda = [&s](int i, int j, int k) -> int& { static int v; s = i + j + k; v = i * j * k; return v; }; int& v = my_apply(lambda, std::make_tuple(4, 5, 6)); std::cout << "s=" << s << ", v=" << v << '\n'; std::cout << "result: " << my_apply(Functor2{}, std::make_tuple(Functor1{}, Functor1{}, 1, 9, -4, 3)) << std::endl; return 0;}https://godbolt.org/z/zn1Ksa5r5

cCa-T
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++17使用std::apply和fold expression对tuple进行遍历
给永远比拿愉快
10-08 5922
C++17使用std::apply和fold expression对std::tuple进行遍历 std::apply函数 先来看这个std::apply函数，这个函数定义在tuple头文件中，函数签名如下： template &lt;class F, class Tuple&gt; constexpr decltype(auto) apply(F&amp;&amp; f, Tuple&amp;&...
C++的std::apply
sinat_31608641的博客
07-03 1065
一、介绍std::apply是 C++17 中引入的一个函数模板，位于头文件中。它允许以元组的方式将参数传递给一个可调用对象（函数、函数指针、成员函数指针、函数对象等）。std::apply其中，F是可调用对象的类型，Tuple是一个std::tuple或类似的可转换为元组类型的对象。std::apply将元组t中的元素作为参数传递给可调用对象f并执行它。它返回可调用对象的结果。
C++17之std::apply与std::make_from_tuple
fl2011sx的博客
07-29 4659
C++17之std::apply与std::make_from_tuple C++17中有两个有意思的语法，是关于std::tuple（或std::pair、std::array等）与函数参数转化的问题的。今天这篇文章我们来研究一下。 std::apply std::apply最主要的作用就是把tuple转化为函数参数，然后去调用函数。请看例子： #include <iostream> int sum(int a, int b, int c) { return a + b + c; }
C++ invoke apply
weixin_33966095的博客
03-21 640
Callable对象，是任何可以调用的东西。函数指针，函数，重载了operator()的对象，lamda #include <iostream> #include <stdlib.h> #include <stdio.h> #include <functional> struct S{ int f1(char c){ ...
std::apply 源码分析
c553110519的专栏
09-13 441
std::apply 源码分析
C++11新特性std::tuple的使用方法
12-16
9. **std::apply**：C++17引入了`std::apply`，它允许将一个可调用对象应用于一个`std::tuple`的所有元素，这使得处理`tuple`中的元素更加方便。 10. **std::tuple_size** 和 **std::tuple_element**：这两个模板类...
tuple:C ++ 11中的简单元组实现
04-01
在C++中，元组还可以与`std::apply`（C++17）或`std::invoke`（C++17）一起使用，以方便地对元组中的函数对象和参数进行操作，这对于函数对象的泛型编程非常有帮助。 总结起来，C++11引入的`std::tuple`为C++开发者...
浅析C++标准库元组（tuple）
09-03
2. 在函数模板中，用于参数的解包（unpacking），配合`std::apply` 或者C++17的`std::index_sequence`。 3. 在容器或类中，作为数据成员，以紧凑的方式存储不同类型的数据。 4. 在算法中，作为临时存储不同类型的...
tuple_cast:在 c++11 元组之间进行转换
07-03
在这个例子中，`tuple_cast`利用了C++17的`std::apply`函数，它可以将元组的元素解开并传递给一个可调用对象（这里是构造函数）。`static_assert`确保了源元组和目标元组的大小相同，以避免类型不匹配的问题。 总的...
混合高斯背景建模的例子（基于c++的opencv实现）
02-01
在OpenCV库中，这种算法得到了很好的支持，使得开发者能够方便地在C++环境下实现。 首先，我们要理解混合高斯模型的基本原理。它假设每个像素的亮度值由多个高斯分布组成，这些分布代表了背景的不同状态。当一个新...
std::apply使用及源码分析
最新发布
红军不怕远征难，万水千山只等闲
12-07 601
std::apply是 C++17 中引入的一个，位于头文件中。它允许以元组的方式将参数传递给一个可调用对象（函数、、成员函数指针、函数对象等）。std::apply以元组 t 的元素作为参数调用对象 f。
【C++ 泛型编程 高级篇】 C++ 17 解析std::apply 的多种应用场景
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-27 1249
std::apply的作用是将一个函数应用于一个元组，但这并不意味着它会对元组的每个元素分别执行函数。相反，它会将元组的每个元素作为参数传递给函数。
c++17 apply、tuple
火苗999℃的博客
09-06 453
c++17 apply说明代码输出参考 说明 以参数的元组调用可调用(Callable) 对象 。 元组不必是 std::tuple ，可以为任何支持 std::get 和 std::tuple_size 的类型所替代；特别是可以用 std::array 和 std::pair 。 代码 #include <iostream> #include <tuple> #include <utility> int add(int first, int second) { ret
c++17中的apply和make_from_tuple
fpcc的专栏
12-11 812
对tuple在参数转换上的两个函数进行分析举例说明
C++(17)：通过apply解构tuple为函数参数
风静如云的博客
11-22 609
【代码】C++(17)：通过apply解构tuple为函数参数。
用C++11实现C++17的apply（动态数组用作函数参数）
weixin_30955341的博客
03-12 860
标题有点错误，apply是用tuple做参数，调用一个函数。这个标题是为了能更好的适配搜索关键字。 动态数组用作函数参数更适合嵌入了脚本环境的C++程序，比如lua或javascript(js)。 若有疏忽或改进，请评论，谢谢。 VS2017虽然实现了一些C++17特性，但没有apply（也许我没发现或有替代），而且即使以后更新添加了，也不是很满足我提到的数组转参数列表。 下面是VS201...
C++17标准库新增类/函数（二）
guxch的专栏
11-30 2393
 std::apply,std::invoke std:apply定义在&lt;tuple&gt;中，因而apply(f,t)的意思就是f(t)，其中f是一个可调用的函数，t是一个tuple,pair,array之类的可以调用std::get和std::tuple_size的参数集合类。 #include &lt;iostream&gt; #include &lt;tuple&gt; #in...
STL(一) 算法小技巧集锦
weijianjain的博客
10-09 491
STL(一) 算法小技巧
c++11 tuple
coolwriter的博客
03-19 331
tuple看似简单，其实它是简约而不简单，可以说它是c++11中一个既简单又复杂的东东，关于它简单的一面是它很容易使用，复杂的一面是它内部隐藏了太多细节，要揭开它神秘的面纱时又比较困难。 　　tuple是一个固定大小的不同类型值的集合，是泛化的std::pair。和c#中的tuple类似，但是比c#中的tuple强大得多。我们也可以把他当做一个通用的结构体来用，不需要创建结构体又获取结构体的特征...
用java实现C++中得库函数std::arg(std::complex)
06-09
在Java中，可以使用 `java.util.function.Function` 接口来实现类似于 C++ 中的 `std::arg(std::complex)` 函数。 首先，我们可以定义一个 `Complex` 类表示复数，包含实部和虚部： ```java class Complex { ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值