Question

我正在尝试实现一个在定位器服务后面抽象的日志系统（以this guide的方式），以便日志系统可以被子类化以用于各种不同的日志记录情况。我希望能够使用printf样式格式字符串而不是＆lt;＆lt;，但这意味着支持可变数量的参数。可变参数模板可以轻松解决这个问题，但是，它们不能是虚拟的，这意味着基本日志记录类不能是抽象的（作为接口）。

理想情况下，我需要的是某种方法让父方法不是模板化的，而只是接受一个参数包，它将转发给正确（模板化）的子方法。我经常看到两种方法，一种是使用va_list，它显然是不安全的，复杂的，并不是真的意味着可以轻松地与可变参数模板交互，而CRTP，它可以工作，但意味着没有指针可以被声明为抽象定位器对象中的基类，但不知道子类类型，这会破坏目的。

以下是假设虚拟模板是一个东西的示例代码：

class Logger
{
    public:
        template <typename ... Args>
        virtual void print(char *filename, int line, std::string &&msg, Args&& ... args) = 0;

    protected:
        template <typename ... Args>
        std::string format(char *filename, int line, std::string &msg, Args&& ... args)
        {
            std::string output = "%s at line %i: " + msg;
            int size = std::snprintf(nullptr, 0, output.c_str());
            // +1 for null termination
            std::vector<char> buf(size + 1);
            std::snprintf(&buf[0], buf.size(), output.c_str(), filename, line, args...);
            return std::string(&buf[0]);
        }


};

class PrintLogger : public Logger
{
    public:
        template <typename ... Args>
        void print(char *filename, int line, std::string &&msg, Args&& ... args)
        {
            std::cout << format(filename, line, msg, args...);
        }
};

以下是使用CRTP解决方案（打破定位器）的示例代码：

template <typename Loggertype>
class Logger
{
    public:
        template <typename ... Args>
        void print(char *filename, int line, std::string &&msg, Args&& ... args)
        {
            Loggertype::print(filename, line, msg, args...);
        }

    protected:
        template <typename ... Args>
        std::string format(char *filename, int line, std::string &msg, Args&& ... args)
        {
            std::string output = "%s at line %i: " + msg;
            int size = std::snprintf(nullptr, 0, output.c_str());
            // +1 for null termination
            std::vector<char> buf(size + 1);
            std::snprintf(&buf[0], buf.size(), output.c_str(), filename, line, args...);
            return std::string(&buf[0]);
        }


};

class PrintLogger : public Logger<PrintLogger>
{
    public:
        template <typename ... Args>
        void print(char *filename, int line, std::string &&msg, Args&& ... args)
        {
            std::cout << format(filename, line, msg, args...);
        }
};

这是定位器：

class Global {
    public:
        static void initialize() { logger = nullptr; }
        static Logger& logging()
        {
            if (logger == nullptr)
            {
                throw new std::runtime_error("Attempt to log something before a logging instance was created!");
            }
            return *logger;
        }
        static void provide_logging(Logger *new_logger) { logger = new_logger; }
    private:
        static Logger *logger;
};

Answer 1

你必须处理2个问题：

迭代打包参数
使用模板参数调用虚函数。

您需要的第一个问题是通过递归函数处理第二个我用boost::any

class Logger
{
public:


    template <typename ... Args>
    std::string print(Args&& ... args)
    {
        start_format();
        interate_on(args...);
        return end_format();
    }
protected:



    template <typename Arg>
    void interate_on(Arg&& arg)
    {
        print(arg);
    }


    template <typename Arg, typename ... Args>
    void interate_on(Arg&& arg, Args&& ... args)
    {
        print(arg);
        interate_on(std::forward<Args>(args)...);
    }

    virtual void start_format() = 0;

    virtual std::string end_format() = 0;

    virtual void print(boost::any& value) = 0;
};

class PrinterLogger : public Logger
{
protected:
    virtual void start_format()
    {

    }

    virtual std::string end_format()
    {
        return std::string();
    }

    virtual void print(boost::any& value)
    {
        // accumulate printf

    }
};

具有可变参数的虚方法

1 个答案: