具有可变参数的虚拟方法答案

【问题标题】：Virtual method with variadic arguments具有可变参数的虚拟方法
【发布时间】：2017-08-25 03:11:17
【问题描述】：

我正在尝试实现一个在定位器服务（this guide 的风格）后面抽象的日志系统，这样日志系统可以针对各种不同的日志情况进行子类化。我希望能够使用 printf 样式格式字符串而不是

理想情况下，我需要某种方式使父方法不被模板化，而只是接受一个参数包，它将转发给正确的（模板化的）子方法。我主要看到了两种方法，一种是使用 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;
};

【问题讨论】：

您使用的是 GCC 还是 Clang？他们知道函数属性format，它使编译器在编译时检查你的printf-like 语句。不知道VS是否也有这个。
使print 成为非虚拟的，让它调用format 然后是一个虚拟函数realPrint(formattedMessage)
@IgorTandetnik 谢谢，我想你刚刚解决了我的问题。虽然它对虚拟可变参数模板的子问题没有帮助，但它解决了我的用例。

标签： c++ c++11 variadic-templates f-bounded-polymorphism

【解决方案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

    }
};

【讨论】：