c++17中的apply和make_from_tuple

一、tuple的应用

前面对std::tuple进行了基础的学习,但是如何更好的应用std::tuple,在STL库里其实有更多的使用方式。在函数参数应用std::tuple的场景中,如何对std::tuple的数据进行操作,也即函数参数与其进行转换的方式。这里就得提到std::apply和std::make_from_tuple两个函数。前者提供了将std::tuple转化为参数并调用相关的函数。而后者功能是类似,只是处理对象时对构造函数的处理,非常有用。下面就分析一下这两个函数。

二、std::apply

先看一下定义:

template 
constexpr decltype(auto) apply(F&& f, Tuple&& t);

看第一个模板形参,class F,一般来说,这个代表着函数。这里F可以表示函数,Lambda与表达式,仿函数及函数指针等。
在官网的文档中,给出一个可能的实现,也就是要实现一个自己的sequence,这就有点麻烦了。换句话说,如果没有这个std::apply,自己实现一个类似的功能,有点小复杂。在上面说了,这个函数的作用是把tuple自动拆封,对应成相关的参数,看一下例程:

#include 
#include 


int Add(int a, int b, int c,int d,int e,int f) 
{
    return a + b + c + d + e + f;
}

class Example 
{
public:
    int Add(int a, int b, int c, int d, int e, int f) 
    {
        return a + b + c + d + e + f;
    }
};

template 
void TestVT(T... args) 
{
    std::cout << sizeof... (args) << std::endl;
    (std::cout << ... << args) << std::endl;
}
int main() {
    //普通函数
    std::tuple t(1,2,3,4,5,6);
    int r = std::apply(Add, std::move(t));
    std::cout << "result is:"<

结果是:

result is:21
result is:21
6
123456

之所以给这么一个挺长参数的函数,目的就是为了更形象的说明这个函数。再看一下cppreference的例子:

#include 
#include 
#include 
 
int add(int first, int second) { return first + second; }
 
template
T add_generic(T first, T second) { return first + second; }
 
auto add_lambda = [](auto first, auto second) { return first + second; };
 
template
std::ostream& operator<<(std::ostream& os, std::tuple const& theTuple)
{
    std::apply
    (
        [&os](Ts const&... tupleArgs)
        {
            os << '[';
            std::size_t n{0};
            ((os << tupleArgs << (++n != sizeof...(Ts) ? ", " : "")), ...);
            os << ']';
        }, theTuple
    );
    return os;
}
 
int main()
{
    // OK
    std::cout << std::apply(add, std::pair(1, 2)) << '\n';
 
    // 错误:无法推导函数类型
    // std::cout << std::apply(add_generic, std::make_pair(2.0f, 3.0f)) << '\n'; 
 
    // OK
    std::cout << std::apply(add_lambda, std::pair(2.0f, 3.0f)) << '\n'; 
 
    // 进阶示例
    std::tuple myTuple(25, "Hello", 9.31f, 'c');
    std::cout << myTuple << '\n';
}

结果是:

3
5
[25, Hello, 9.31, c]

在这个网页上有句说明:元组不必是 std::tuple ,可以为任何支持 std::get 和 std::tuple_size 的类型所替代;特别是可以用 std::array 和 std::pair 。对应着例子就应该明白了。

三、std::make_from_tuple

这个用来处理对象的,也就是说有构造函数,非平凡的。看一下例子:

class Foo 
{
public:
    Foo(int first, float second, int third) 
    {
        std::cout << first << ", " << second << ", " << third << std::endl;
    }
    int operator ()()
    {
        std::cout << "is call" << std::endl;
        return 1;
    }
};

void TestMake()
{
    auto tuple = std::make_tuple(42, 3.14f, 0);
    auto a = std::make_from_tuple(std::move(tuple));
    std::cout << "return is:" << a() << std::endl;
}
int main() 
{
    TestMake();
    return 0;
}

多么简单,而如果没有这个函数,就得自己封装并解析std::tuple中的参数,转化成对象。这就是利用上面的变参模板函数和Lambda表达式了。

class Foo 
{
public:
    Foo(int a, double b, const std::string& c,int d) : a_(a), b_(b), c_(c),d_(d) {}
    int operator ()()
    {
        std::cout << a_ << " " << b_ << " " << c_ << " " << d_ << std::endl;
        return 1;
    }
private:
    int a_,d_=0;
    double b_ = 0.0;
    std::string c_ = "";
};

// 自行封装构造过程
template 
T Instance(Args &&...args) 
{
    return T(args...);
}

void TestOwner() 
{
    std::tuple t(3, 1.9, "test",8);
    Foo&& f = std::apply([](auto &&...args)->Foo {return Instance(args...); }, std::move(t));
    f(); 

}

int main() 
{
    TestOwner();
    return 0;
}

反复提到过一句话,简单才是王道。为什么js和python流行,原因何在?所谓功能强大,其实都是在简单的基础上喊出来的。c++功能更强大,怎么没有他们流行?这就是原因,不简单。

四、总结

std::apply和std::make_from_tuple可以说是一对相互配合操作的工具接口,通过这两个就可以把一些较为复杂的对std::tuple的操作变得容易简单。看STL库中,还有一个forward_as_tuple函数,基本都差不多,有兴趣可以认真看看。
其实在实际工作也可以发现,一个好的接口往往比实现本身更容易为人所称道。本文的这两个函数,其实就可以理解为std::tuple基础设施,让其在实际应用中更方便快捷安全的使用的一个接口。这个现象在STL中其实很多,这也符合一个普通应用库的要求。不过,不是说这样的接口越多越好,还是尽量简化成较少的接口为妙。毕竟,学习的东西越多,反而会让开发者产生厌烦。过犹不及就是这个道理。

你可能感兴趣的:(C++11,c++)