如何替换 `{ lock_guard lock(obj.mut); obj.a_stringstream << a << b /*...*/ << n;}` 带有方法调用

Question

我有一个struct 喜欢

struct log {
    boost::mutex mut;
    std::stringstream a_stringstream;
    //...
    };

在我的代码中，我有一个向量并且经常这样做

{
    boost::lock_guard <boost::mutex> lock(logs[AN_ENUM].mut);
    logs[AN_ENUM].a_stringstream << "something" << a_double << a_string << etc;
}

每次我想记录一些东西时，都有锁保护和括号似乎很冗长。起初我想也许我可以为我的结构重载 << 运算符，但我读过它，我认为这行不通。有什么好方法可以将其压缩为方法调用吗？

Answer 1

您可以创建一个可变参数模板函数（例如log_it），该函数接受AN_ENUM 加上可变数量的记录，锁定mutex 一次，然后将所有内容流式传输到a_stringstream。例如：

#include <mutex>
#include <sstream>
#include <vector>

class save_stream
{
    std::ostream&      os_;
    char               fill_;
    std::ios::fmtflags flags_;
    std::streamsize    precision_;

public:
    ~save_stream()
    {
        os_.fill(fill_);
        os_.flags(flags_);
        os_.precision(precision_);
    }

    save_stream(const save_stream&) = delete;
    save_stream& operator=(const save_stream&) = delete;

    explicit save_stream(std::ostream& os)
        : os_(os)
        , fill_(os.fill())
        , flags_(os.flags())
        , precision_(os.precision())
        {}
};

struct log
{
    std::mutex mut;
    std::stringstream a_stringstream;
};

std::vector<log> logs(10);

enum : std::size_t {AN_ENUM};

void
log_one(std::size_t)
{
}

template <class Arg0, class ...Args>
void
log_one(std::size_t log, Arg0 const& arg0, Args const& ...args)
{
    logs[log].a_stringstream << arg0;
    log_one(log, args...);
}

template <class ...Args>
void
log_it(std::size_t log, Args const& ...args)
{
    std::lock_guard<std::mutex> lock(logs[log].mut);
    save_stream s{logs[log].a_stringstream};
    logs[log].a_stringstream << "log " << log << " says : ";
    log_one(log, args...);
    logs[log].a_stringstream << '\n';
}

这不是大量的代码。 log_it 接受一个整数常量，使用它来索引logs 以锁定互斥锁，吐出前缀字符串，然后使用常量日志索引和可变数量的参数调用log_one 以注销。

log_one 然后简单地记录第一个参数，然后在包的其余部分递归调用 log_one。

可以这样使用：

log_it(AN_ENUM, std::fixed, std::setprecision(3), "i = ", 4.5);
log_it(AN_ENUM,                                   "j = ", 4.5);

导致logs[0].a_stringstream 持有：

log 0 says : i = 4.500
log 0 says : j = 4.5

我确信语法可以被巧妙地改进为更漂亮的东西，但这可以理解基本思想：传递可变数量的 args，锁定在调用堆栈的顶部，然后一个一个地处理每个 args。

“日志级别”可能只是log_it 的另一个参数。

Answer 2

我想不出这个模板重载

template<typename param>
auto operator<<(param &&Param)
{
    boost::lock_guard <boost::mutex> lock(mut);

    a_stringstream << std::forward<param>(Param);

    return *this;
}

我不知道您阅读的内容可能表明这种方法行不通，但无论您阅读什么，它都是错误的。我的示例可能需要在这里和那里进行一些调整，具体取决于您的实际课程，但理论上它应该是非常可行的。