在 std::function 对象中存储模板化参数包

Question

我开发了一个用于其他库和应用程序的库。 它由应用程序提供实际的日志记录工具。 库应仅定义一组详细级别并将消息传递给应用程序，如果发生了应该记录的事情。 因此，我的想法是在我的库中存储一个std::function对象，该对象实际上指向客户端应用程序中的某个回调。 之前请注意，通过va_start, va_list和va_end访问的 C 风格可变参数模板参数是没有选项的。 这是因为客户端可能会使用非基于 printf 的方案，例如spdlog 。 我知道没有提供 MWE，但那是因为代码甚至无法编译。

图书馆：

.hpp
enum class severity_t
{
    trace = 0,
    debug = 1,
    warn = 2,
    error = 3,
    critical = 4
};

template <typename ...args_t>
using logging_callback_t = std::function<void(severity_t, std::string, args_t...)>;

template <typename ...args_t>
extern logging_callback_t<args_t...> logging_callback;

template <typename ...args_t>
void log(severity_t level, const std::string& msg, args_t&& ...args)
{
    logging_callback<args_t...>(level, msg, std::forward<args_t>(args)...);
}

template <typename ...args_t>
void set_logging_cbk(logging_callback_t<args_t...> func)
{
    logging_callback<args_t...> = func;
}

.cpp
template <typename ...args_t>
logging_callback_t<args_t...> logging_callback;

std::string to_append("something");
log(severity_t::warn, "abc {}", to_append);

客户端应用程序：

template <typename ...args_t)
void log_from_lib_a(severity_t level, const std::string& msg, args_t&& args...)
{
    if(level == severity_t::warn)
    {
        spdlog::warn(msg, std::forward<args_t>(args)...);
    }
}


int main()
{
    set_logging_cbk<???>(boost::bind(&log_from_lib_a<???&...>, 
                                     boost::placeholders::_1, 
                                     boost::placeholders::_2,
                                       ???);
} 

我所知道的关于可变参数模板参数实际类型的代码中唯一的地方是从库中登录时。 客户端如何注册一个他不知道参数的回调？ 这是我第一次使用参数包，所以我希望代码/想法至少在某种程度上是合理的。 除此之外，为什么在调用 std::function 实例的方法时需要指定可变参数类型：

logging_callback<args_t...>(level, msg, std::forward<args_t>(args)...);

代替

logging_callback(level, msg, std::forward<args_t>(args)...);

PS：需要 cstd++11，如果有更新版本的更好解决方案，我也很高兴听到它！

Answer 1

你不能有一个虚拟模板方法，这主要是你想要的std::function后面的类型擦除。

当你控制你的库时，你知道每个原型真正使用过，所以你可以创建一个符合你需要的记录器接口：

struct ILogger
{
    virtual ~ILogger() = default;

    virtual void write(severity_t, const std::string&) = 0;
    virtual void write(severity_t, const std::string&, int) = 0;
    virtual void write(severity_t, const std::string&, int, const std::string&) = 0;
    virtual void write(severity_t, const std::string&, float) = 0;
    // ...
};

void set_logger(ILogger&); // custom point

然后提供一种从可变参数函子轻松创建类的方法，例如：

template <typename Functor>
struct LoggerT : ILogger, Functor
{
    using Functor::Functor;
    using Functor::operator();

    void write(severity_t level, const std::string& format) override { (*this)(level, format);}
    void write(severity_t level, const std::string& format, int v1) override { (*this)(level, format, v1);}
    void write(severity_t level, const std::string& format, int v1, const std::string& v2) override { (*this)(level, format, v1, v2);}
    void write(severity_t level, const std::string& format, float v1) override { (*this)(level, format, v1);}
    // ...
};

template <typename Func>
LoggerT<Func> make_logger(Func func) { return {func}; }

然后你的客户只需要写：

struct SpdLogger {
    template <typename ... Ts>
    void operator () (severity_t level, const std::string& msg, Ts&& args...)
    {
        if (level == severity_t::warn)
        {
            spdlog::warn(msg, std::forward<Ts>(args)...);
        }
    }
};

int main()
{
    LoggerT<SpdLogger> logger;
    set_logger(logger);
    // ...
}

在 C++14 中，使用泛型 lambda：

auto logger = make_logger([](severity_t level, const std::string& msg, auto&& args...)
    {
        if(level == severity_t::warn)
        {
            spdlog::warn(msg, decltype(args)(args)...); // decltype(args) is the forward
        }
    });
set_logger(logger);