如何更换`{lock_guard锁（obj.mut）; obj.a_stringstream <<一个<< 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 

我敢肯定，语法可以巧妙的东西更漂亮，但得到的基本想法跨越：传递可变数量的参数，锁定在调用堆栈的顶部，然后逐个处理每个参数。

“日志级别”可能只是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; 
} 

我不知道你读了什么可能表明这种做法不会工作，但无论你读什么，都是错误的。我的例子可能需要一些调整，在这里和那里，取决于你的实际课程，但理论上它应该是非常可行的。