3

我正在探索 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;
    }
};

它是干什么用的？

4

2 回答 2

3

result is partially specialized on the function type add_ints_only(State, T).

The purpose is that code that wants to know the type that the functor add_ints_only returns with particular argument types can inquire by writing:

typedef typename add_ints_only::result<add_ints_only(arg1_type, arg2_type)>::type
  result_type;

e.g.

template<typename U, typename V> void foo(U u, V v) {
  typename add_ints_only::result<add_ints_only(arg1_type, arg2_type)>::type
    result = add_ints_only()(u, v);
}

This is useful for functors that can return different types depending on their operator() argument types.

于 2012-11-08T11:56:07.917 回答
3

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

特别是 add_ints_only 是多态函数对象概念的模型。

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

它类似于STL 中的Adaptable Unary Function概念，它应该提供嵌套的 ::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 函数的调用。它允许对不同数量的参数进行专门化。

它是如何工作的：

现场演示

#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

看起来类似于普通的函数调用。

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

decltype( PolymorphicFunctionObject()( long(),unsigned() ) )
于 2012-11-08T12:02:07.657 回答