如何检测<<运算符链的末端

Question

我工作的公司有一个 Logger 类，我们用它来安排从多个线程到窗口的打印输出。它使用 printf 样式的格式，我正在尝试创建一个包装器以使其表现得像 cout。它几乎可以工作，我可以像这样调用包装器类：

wlog->info() << "hello: " << 1;

它通过调用返回的帮助类的析构函数在链的末尾刷新wlog->info()（它与 RAII 概念非常相似）。

但是，C++ 会发出警告，因为wlog->info()返回的是右值，并且会出现警告，因为operator<<重载需要左值引用。是否有解决此警告的方法，或者无需求助于特殊的行尾函数/字符/事物即可检测 << 链末尾的替代方法？

在下面编辑：抱歉花了这么长时间发布这篇文章，周末忙于圣诞节准备:) 我无法显示 Logger 类本身的代码，但它的行为与 printf 大致相同。调用 log->info("Hello: %d", 22); 将打印“信息 - 你好 22”。

logger_wrapper.h

#include<sstream>
#include<iomanip>

#include "logger/logger.h"

namespace logger {
    // helper class // can't be a nested class (i think). need to be able to return it
    class LoggerHelper {
    private:
        Logger* log;
        std::stringstream ss; // using stringstream for auto-string conversion
        int level; // the type of log
        int precision;
        bool copy_flag;

    public:
        // constructor
        // prefix is the name of the interface which is supplied by LoggerWrapper
        // precision is floating point precision
        LoggerHelper(int level_, int precision_, std::string prefix_, Logger* log_);
        // copy constructor
        LoggerHelper(const LoggerHelper& other);

        // destrutor outputs the message to log
        ~LoggerHelper();

        // chain together << operations
        template<typename T>
        friend LoggerHelper& operator<<(LoggerHelper&, const T&);

        // enums for variations of log
        enum LogLevels {
            INFO,
            DEBUG,
            WARN,
            ERROR,
            MAX_LEVEL,
        };
    };

    // chain together << operations
    template<typename T>
    LoggerHelper& operator<<(LoggerHelper& out, const T& in) {
        out.ss << in;
        return out;
    };

    // main wrapper class
    class LoggerWrapper {
    private:
        Logger* log;
        std::string prefix;
        int precision; // float point precision

    public:
        // generic constructor
        // precision defaults to 2
        LoggerWrapper(std::string prefix_, Logger* log_);
        // with precision
        LoggerWrapper(std::string prefix_, int precision_, Logger* log_);

        // not responsible for any resources
        ~LoggerWrapper(){}; 

        // log functions
        LoggerHelper info();
        LoggerHelper debug();
        LoggerHelper warn();
        LoggerHelper error();
    };

}

logger_wrapper.cpp

#include "logger_wrapper/logger_wrapper.h"

namespace logger {
    // constructor
    LoggerHelper::LoggerHelper(int level_, int precision_, std::string prefix_, Logger* log_) :
    level(level_),
    precision(precision_),
    log(log_)
    {
        copy_flag = false;
        ss << std::fixed << std::setprecision(precision);
        ss << prefix_;
    }
    // copy constructor
    LoggerHelper::LoggerHelper(const LoggerHelper& other) {
        copy_flag = true;
        level = other.level;
        precision = other.precision;
        log = other.log;
        ss << std::fixed << std::setprecision(precision);
        ss << other.ss.str();
    }

    // destrutor outputs the message to log
    LoggerHelper::~LoggerHelper() {
        // only run if this was a copy
        if (copy_flag) {
            // choose a log level
            void(Logger::*func)(const char*, ...) = &Logger::info;
            switch (level) {
            case(LoggerHelper::DEBUG) :
                func = &Logger::debug;
                break;

            case(LoggerHelper::WARN) :
                func = &Logger::warn;
                break;

            case(LoggerHelper::ERROR) :
                func = &Logger::error;
                break;

            // defaults to log->info
            default:
                break;
            }

            // output to log
            (log->*func)("%s", ss.str().c_str());
        }
    }

    // generic constructor
    LoggerWrapper::LoggerWrapper(std::string prefix_, Logger* log_) :
        prefix(prefix_),
        precision(2),
        log(log_) {}

    // with precision
    LoggerWrapper::LoggerWrapper(std::string prefix_, int precision_, Logger* log_) :
        prefix(prefix_),
        precision(precision_),
        log(log_) {}

    // log functions
    LoggerHelper LoggerWrapper::info() {
        return LoggerHelper(LoggerHelper::INFO, precision, prefix, log);
    }
    LoggerHelper LoggerWrapper::debug() {
        return LoggerHelper(LoggerHelper::DEBUG, precision, prefix, log);
    }
    LoggerHelper LoggerWrapper::warn() {
        return LoggerHelper(LoggerHelper::WARN, precision, prefix, log);
    }
    LoggerHelper LoggerWrapper::error() {
        return LoggerHelper(LoggerHelper::ERROR, precision, prefix, log);
    }
}

编辑2：

我尝试了 bolov 更改运算符重载以使用右值的答案（我什至从未想过要尝试这个，我只是假设它必须是这样的结构）。在将所有相关函数更改为返回右值并将内容包装在 std::move 中后，它会在没有警告的情况下进行编译，但会引发“访问冲突读取”。

logger_wrapper.h 中的更改

// chain together << operations
    template<typename T>
    LoggerHelper&& operator<<(LoggerHelper&& out, const T& in) {
        out.ss << in; // throws: Access violation reading location 0xFFFFFFFFFFFFFFFF
        return std::move(out);
    };

logger_wrapper.cpp 中的更改

// log functions
    LoggerHelper&& LoggerWrapper::info() {
        return std::move(LoggerHelper(LoggerHelper::INFO, precision, prefix, log));
    }
    LoggerHelper&& LoggerWrapper::debug() {
        return std::move(LoggerHelper(LoggerHelper::DEBUG, precision, prefix, log));
    }
    LoggerHelper&& LoggerWrapper::warn() {
        return std::move(LoggerHelper(LoggerHelper::WARN, precision, prefix, log));
    }
    LoggerHelper&& LoggerWrapper::error() {
        return std::move(LoggerHelper(LoggerHelper::ERROR, precision, prefix, log));
    }

我非常不熟悉将右值作为参数传递。我唯一一次这样做是在编写移动构造函数时。我不知道这些 rvalue 参数何时超出范围，也不知道如何维持其“生命”以确保它在该行完成之前保持有效。

Answer 1

您应该展示您的实现，以便我们可以看到您尝试过的内容并帮助您解决这个问题。

在不知道您拥有什么的情况下，我的解决方案是简单地使用右值引用：

info_t&& operator<<(info_t&& info, int);
{
   // ...
   return std::move(info);
}