Question

我需要一个调度程序功能，如下所示

template<typename T>
T dispatcher() {
    // if T is double
    return _func_double();
    // if T is int
    return _func_int();
    // if T is char*
    return _func_char_pointer();
}

，其用法如下所示

// some code that use above dispatcher
template<typename T1, typename T2, typename T3>
void do_multiple_thing(T1 *a1, T2 *a2, T2 *a3) {
    *a1 = dispatcher<T1>();
    *a2 = dispatcher<T2>();
    *a3 = dispatcher<T3>();
}

你能告诉我如何实现吗？

P.S。
-仅适用于内置类型的解决方案。
-预处理和模板处理都是可以接受的。

Answer 1

如果您的编译器具有C ++ 17支持，则此代码段应该有效：

template<typename T>
T dispatcher() {
    // if T is double
    if constexpr (std::is_same<T, double>::value)
        return _func_double();
    // if T is int
    if constexpr (std::is_same<T, int>::value)
        return _func_int();
    // if T is char*
    if constexpr (std::is_same<T, char*>::value)
        return _func_char_pointer();
}

否则，您将必须进行模板专门化，并对想要的每个参数进行重载

//only needed for static assert
template<typename T>
struct always_false : std::false_type {};


template<typename T>
T dispatcher() 
{ 
//to make sure that on type you didn't overload you will have exception
    throw std::exception("This type was not overloaded")
//static assert that will provide compile time error
    static_assert(always_false<T>::value , "You must specialize dispatcher for your type");
}
//or to get compile time error without static assert 
template<typename T>
T dispatcher() = delete; //the simplest solution

template<>
double dispatcher<double>() 
{
    return _func_double();
}
//... and so on for all other functions

Answer 2

在C ++ 17中，如果constexpr和std::is_same可以合并使用：

template<typename T>
T dispatcher() {
    if constexpr (std::is_same<T, double>::value) {
        return _func_double();
    } else if constexpr (std::is_same<T, int>::value) {
        return _func_int();
    } else if constexpr (std::is_same<T, char*>::value) {
        return _func_char_pointer();
    } else {
        return {}; // or static_assert(always_false<T>::value); ?
    }
}

在此之前，您可能会使用带有过载的专业化或标签分派：

template<typename T>
T dispatcher() {
    return {}; // or static_assert(always_false<T>::value); ?
}

template<>
double dispatcher() {
    return _func_double();
}

template<>
int dispatcher() {
    return _func_int();
}

template<>
char* dispatcher() {
    return _func_char_pointer();
}

或

template<typename T> struct tag {};


template<typename T>
T dispatcher(tag<T>) = delete; // or { return {}; } ?

double dispatcher(tag<double>) { return _func_double(); }

int dispatcher(tag<int>) { return _func_int(); }

char* dispatcher(tag<char*>) { return _func_char_pointer(); }

// some code that use above dispatcher
template<typename T1, typename T2, typename T3>
void do_multiple_thing(T1 *a1, T2 *a2, T2 *a3) {
    *a1 = dispatcher(tag<T1>());
    *a2 = dispatcher(tag<T2>());
    *a3 = dispatcher(tag<T3>());
}

Answer 3

template <typename T>
T fetch_magic_value();

template <>
int fetch_magic_value<int>() { return 23; }

template <>
char fetch_magic_value<char>() { return ' '; }

template <>
std::string fetch_magic_value<std::string>() { return "tada"; }

template<typename T>
void do_multiple_thing(T *x) {
  *x = fetch_magic_value<T>();
}

template<typename T, typename... Args>
void do_multiple_thing(T *first, Args *...args)
{
    do_multiple_thing(first);
    do_multiple_thing(args...);
}

https://wandbox.org/permlink/v2NMhoy8v3q5VhRf

C ++ 17版本： https://wandbox.org/permlink/0pi08jvYF5vlIpud

Answer 4

如果您需要用于编写此类调度程序的通用解决方案，则可以使用类似的方法：

// calls the first function that has return type `T` with no arguments
template <class T, class F, class... Fs>
constexpr T call_by_return_type(F&& f, Fs&&... fs) {
    if constexpr (std::is_same_v<T, std::invoke_result_t<F>>) {
        return f();
    } else if constexpr (sizeof...(fs) > 0) {
        return call_by_return_type<T>(std::forward<Fs>(fs)...);
    } else {
        static_assert(
            sizeof(T) == 0,
            "`T` must match at least one function's return type"
        );
    }
}

然后您可以将调度程序创建为功能的组合（可以是不带参数调用的任何功能对象）：

template <class T>
constexpr T dispatcher() {
    return call_by_return_type<T>(
        _func_double,
        _func_int,
        _func_char_pointer
    );
}

Example in godbolt.org

注意：：我假设您已经具有_func_<return-type>个功能，需要对其进行分组以构成一个调度程序，否则我会想到更优雅的界面。

内置类型的基于C ++类型的分派

4 个答案: