具有可变参数的虚拟方法

我试图在一个定位器服务（以本指南的形式）抽象后实现一个日志记录系统，以便日志记录系统可以分类为各种不同的日志记录情况。 我宁愿能够使用printf样式格式字符串而不是<<，但这意味着支持可变数量的参数。 变量模板可以很容易地解决这个问题，但是，它们不能是虚拟的，这意味着基础日志记录类不能是抽象的（作为接口）。

理想情况下，我需要的是让父方法不是模板化的方法，而是接受一个参数包，它将向右（模板化）子方法转发。 我主要看到了这样做的两种方式，一种是使用va_list，这显然是不安全的，复杂的，并不真正意味着与variadic模板轻松交互，而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;
};

---

你必须处理两个问题：

迭代打包的参数

使用模板参数调用虚函数。

你需要的第一个问题是递归函数的处理第二个我用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

    }
};

链接地址: http://www.djcxy.com/p/51583.html

上一篇: Virtual method with variadic arguments

下一篇: How to properly pass C strings to a lambda inside a variadic template function