c++ - 奇怪的模板结构定义

Question

我正在探索 boost 库代码并发现以下奇怪的结构定义。

struct add_ints_only
{
    template<typename T>
    struct result;

    template <typename State, typename T>
    struct result<add_ints_only(State, T)> // what's going on here?
    {
        typedef typename boost::remove_const<
            typename boost::remove_reference<State>::type>::type type;
    };

    template <typename State, typename T> 
    State
    operator()(State const& state, T const& /*x*/) const
    {
        return state;
    }

    int
    operator()(int state, int x) const
    {
        return x + state;
    }
};

它有什么用？

Answer 1

我猜你正在寻找一些 Boost.Fusion东西或类似的东西。

特别是 add_ints_only 是 Polymorphic Function Object 的模型概念。

多态函数对象提供多态operator()，可以重载也可以是模板。 operator() 的结果类型可能会根据其参数类型而有所不同。

它在某些方面类似于Adaptable Unary Function来自 STL 的概念，它应该提供嵌套的::result_type。

但是多态函数对象的结果类型可能会根据传递给 operator() 的参数类型而有所不同。因此，应该使用比单个::result_type 更强大的工具来根据 operator() 的参数类型获取结果类型。

template <typename State, typename T>
struct result<add_ints_only(State, T)> // ...

此语法是类的部分特化。

add_ints_only(State, T)

是返回 add_ints_only 并以 Stage 和 T 作为参数的函数类型。

本身，这种类型并不是没有意义——你不会返回 add_ints_only。它只是类型参数传递的一种方便形式——它看起来像调用 add_ints_only 函数。并且它允许对不同数量的参数进行专门化。

这是它的工作原理:

live demo

#include <boost/utility/result_of.hpp>
#include <typeinfo>
#include <iostream>
#include <ostream>

using namespace std;

struct PolymorphicFunctionObject
{
    template<typename T> struct result;

    template<typename Arg>
    struct result< PolymorphicFunctionObject(Arg) >
    {
        typedef Arg type;
    };

    template<typename Arg1,typename Arg2>
    struct result< PolymorphicFunctionObject(Arg1,Arg2) >
    {
        typedef Arg2 type;
    };

    template<typename Arg>
    Arg operator()(Arg t) const
    {
        return t;
    }

    template<typename Arg1,typename Arg2>
    Arg2 operator()(Arg1 t1,Arg2 t2) const
    {
        return t2;
    }
};

int main()
{
    cout << typeid
    (
        PolymorphicFunctionObject::result< PolymorphicFunctionObject(int) >::type
    ).name() << endl;
    // Output is - int

    cout << typeid
    (
        PolymorphicFunctionObject::result< PolymorphicFunctionObject(char,double) >::type
    ).name() << endl;
    // Output is - double

    // -----------------
    // Or using boost::result_of, which queries ::result internally:

    cout << typeid
    (
        boost::result_of< PolymorphicFunctionObject(short) >::type
    ).name() << endl;
    // Output is - short

    cout << typeid
    (
        boost::result_of< PolymorphicFunctionObject(char,float) >::type
    ).name() << endl;
    // Output is - float

    // ------------------
    // Or using C++11 decltype:
    cout << typeid
    (
        decltype( PolymorphicFunctionObject()( long() ) )
    ).name() << endl;
    // Output is - long

    cout << typeid
    (
        decltype( PolymorphicFunctionObject()( long(),unsigned() ) )
    ).name() << endl;
    // Output is - unsigned int

}

如你所见，结果类型查询语法:

boost::result_of< PolymorphicFunctionObject(short) >::type
boost::result_of< PolymorphicFunctionObject(char,float) >::type

看起来与正常的函数调用相似。

附言在 C++11 中不需要这些东西，因为 decltype 的存在，它可以用来自动获取结果的类型。例如:

decltype( PolymorphicFunctionObject()( long(),unsigned() ) )