2

我正在尝试将函数绑定到类型中-考虑以下测试程序：

#include <utility>

template <class Ret, class Arg>
struct func {
    typedef Ret (&ref)(Arg);
    template <ref Fn>
    struct bind {
        template <class NewArg>
        Ret operator()(NewArg&& arg) {
            return Fn(std::forward<Arg>(arg));
        }
    };
};

int foo(int i) {
    return i;
}

typedef func<int, int>::bind<foo> Foo;

int main(int argc, char** argv) {
    Foo foo_obj;
    return foo_obj(argc);
}

这行得通，但我个人觉得func<int, int>::bind<foo>丑陋，而且它也是多余的 - 但我似乎无法func::bind<foo>从模板参数中推断出 Ret 和 Arg 来绑定（或道德等价的 therof）。我会做这样的事情：

template <class Ret, class Arg>
constexpr auto bind_func(typename func<Ret, Arg>::ref f) -> typename func<Ret, Arg>::bind<f> {
    return {};
}

但是，由于 f 不能保证是常量表达式，因此无法编译，因为编译器无法知道 f 是有效的模板参数。

有没有办法在没有持续冗余的情况下做到这一点？

4

1 回答 1

1

如果您可以接受宏，这是一个可能的解决方案：

#include <utility>

template <class Ret, class Arg>
struct func {
    typedef Ret (&ref)(Arg);
    template <ref Fn>
    struct bind {
        template <class NewArg>
        Ret operator()(NewArg&& arg) {
            return Fn(std::forward<Arg>(arg));
        }
    };
};

template<typename T>
struct traits { };

template<typename R, typename A>
struct traits<R(A)>
{
    typedef R return_type;
    typedef A arg_type;
};

int foo(int i) {
    return i;
}

#define TYPE_WRAP(f) \
    func< \
        traits<decltype(f)>::return_type, \
        traits<decltype(f)>::arg_type \
        >::bind<f>

int main(int argc, char** argv) {
    TYPE_WRAP(foo) foo_obj;
    return foo_obj(argc);
}
于 2013-02-25T01:00:11.040 回答