如何模拟一个带有模板化args的函数，并在c ++中对它们应用模板化函数？

Question

I have a bunch of static class functions that take in varying number of {string, int, float} params and an Output param. There may be different behavior for the same parameters based on the function called. For example:

static void ChangeOutput1(const string& foo, int bar, Output* output);
static void ChangeOutput2(int bar, Output* output);
static void ChangeOutput3(float foo, Output* output);
static void ChangeOutput4(float foo, Output* output);  // behaves differently from ChangeOutput3

I'd like to have a simple, safe way of writing templates to perform a similar behavior over each of the functions, basically calling with an Output argument and converting it to a string to return. Ideally without having to specify the parameter types again. It might look something like this:

template<typename... Args, int (*ChangeOutputFn)(Args...)>
string OutputString(Args... args) {
    Output output;
    ChangeOutputFn(args..., &output);
    return ConvertToString(output);
}

// Is there a way to alias static templated functions?
using StringOutput1 = OutputString<ChangeOutput1>;
using StringOutput2 = OutputString<ChangeOutput2>;
using StringOutput3 = OutputString<ChangeOutput3>;

I'm not sure how to achieve this. I'm both unsure of how to write OutputString and how I would alias or define the static functions. There are less elegant solutions, but they require repetitive boilerplate that I'd like to avoid.

Answer 1

With a class, you may do something like:

template <typename T, T f> struct OutputString;

template<typename... Args, void (*ChangeOutputFn)(Args...)>
struct OutputString<void (*)(Args...), ChangeOutputFn>
{
    template <typename ... Ts>
    auto operator()(Ts... args)
    -> decltype(ChangeOutputFn(std::forward<Ts>(args)..., std::declval<Output *>()),
                std::string{})
    {
        Output output;
        ChangeOutputFn(std::forward<Ts>(args)..., &output);
        return ConvertToString(output);
    }
};

And then

using StringOutput1 = OutputString<decltype(&ChangeOutput1), &ChangeOutput1>;
using StringOutput2 = OutputString<decltype(&ChangeOutput2), &ChangeOutput2>;
using StringOutput3 = OutputString<decltype(&ChangeOutput3), &ChangeOutput3>;

and use it as

std::string s2 = StringOutput2{}(42);
std::string s3 = StringOutput3{}(4.2f);

Demo

Answer 2

You can do this if you move the Output argument to the front.

static void ChangeOutput1(Output*, const std::string& foo, int bar);
static void ChangeOutput2(Output*, int bar);
static void ChangeOutput3(Output*, float foo);
static void ChangeOutput4(Output*, float foo);

Now you can have this template:

template<typename... Args>
std::function<std::string(Args...)>
mkOutput (void (*ChangeOutputFn)(Output*, Args...))
{
    return [ChangeOutputFn](Args... args)->std::string{
        Output output;
        ChangeOutputFn(&output, args...);
        return ConvertToString(output);
    };
}

and "function aliases" look like this:

auto a1 = mkOutput(ChangeOutput1);
auto a2 = mkOutput(ChangeOutput2);
auto a3 = mkOutput(ChangeOutput3);
auto a4 = mkOutput(ChangeOutput4);

Note 1. You cannot have this syntax

OutputString<ChangeOutput1>

because ChangeOutput1 is a value and OutputString must either know its type beforehand or receive it as another template argument.

It is possible to have something like this

OutputString<decltype(ChangeOutput1), ChangeOutput1>

and then eliminate the repetition with a macro, but that's just ugly.

I choose to pass the function at run time rather than at compile time, it's easier this way.