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);
    // ...
}

以及在具有常规lambda的C ++ 14中：

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);

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

1 个答案: