Question

template<typename T> struct A 
{
    static T x(T, T) { }
    static T y(T, T) { }
};

template<typename T> struct B 
{
    static T x(T, T) { }
    static T y(T, T) { }
};

struct Dispatcher
{
    template<template<typename> class TC, ??? TStaticFunc, 
             typename T1, typename T2> 
    static std::common_type_t<T1, T2> call(T1 mI, T2 mJ)
    {
        return TC<std::common_type_t<T1, T2>>::*TStaticFunc(mI, mJ);
    }
};

Dispatcher::call<A, x>(12.f, 5);
Dispatcher::call<B, x>(1.f, 51);
Dispatcher::call<A, y>(2.f, 25);
Dispatcher::call<B, y>(5.f, 3);

是否可以创建一个像Dispatcher::call一样的模板化函数？我想分别传递类类型和静态函数名称。

或者是通过A<..:>::x实现这种派遣的唯一可行方式？

Answer 1

嗯，你可以做到，如果你真的，真的，真的想要。您只需为每个静态函数名称定义类型，函数或变量（基本上是编译时唯一的）。这个选项之一：

namespace detail
{
    template <typename T>
    struct x
    {
        static decltype(&T::x) get() { return &T::x; }
    };

    template <typename T>
    struct y
    {
        static decltype(&T::y) get() { return &T::y; }
    };

    // etc, you can use macros here to avoid boilerplate
}

现在改变Dispatcher ......

struct Dispatcher
{
    template<template<typename> class TC, template<typename> class FuncGetter,
        typename T1, typename T2> 
        static typename std::common_type<T1, T2>::type call(T1 mI, T2 mJ)
    {
        typedef TC<typename std::common_type<T1, T2>::type> T;
        auto staticMemberFunc = FuncGetter<T>::get();
        return staticMemberFunc(mI, mJ);
    }
};

现在关注代码：

using namespace detail;
Dispatcher::call<A, x>(12.f, 5);
Dispatcher::call<B, x>(1.f, 51);
Dispatcher::call<A, y>(2.f, 25);
Dispatcher::call<B, y>(5.f, 3);

作品。如果您决定遵循此模式，我建议您将x和y更改为x_tag或其他内容。

或者，您可以编写一个宏来代替Dispatcher::call。

将静态成员函数作为模板参数传递

1 个答案: