C++ 用于多进程同步的输出流锁定？

有多个进程，所有进程都在同一个输出流上写入（例如使用

std:：cout

），是否有办法锁定流，以便当进程开始写入自己的消息时，它可以一直写入到最后（例如使用

std:：endl

）

---

我需要一种便携的方法。你真倒霉。您必须使用taget OS提供的任何东西。这意味着使用全局/系统范围的互斥体或类似函数的

lockf（）。您可以使用一些第三方库来满足可移植性要求，例如。
您运气不好。您必须使用taget OS提供的任何东西。这意味着使用全局/系统范围的互斥体或类似函数的
lockf（）。您可以使用一些第三方库来满足可移植性要求，例如。
如果您使用的是类UNIX操作系统，那么您可以使用
stringstream
适配器模拟所需的行为。这可能不是实现它的最佳方法，但是只要遇到
std:：endl
，就触发一个
write
调用

// Assume fd is in blocking mode
class fdostream : public std::ostringstream {
    typedef std::ostream & (*manip_t) (std::ostream &);
    struct fdbuf : public std::stringbuf {
        int fd_;
        fdbuf (int fd) : fd_(fd) {}
        int sync () {
            int r = ::write(fd_, str().data(), str().size());
            str(std::string());
            return (r > 0) ? 0 : -1;
        } 
    } buf_;
    std::ostream & os () { return *this; }
public:
    fdostream (int fd) : buf_(fd) { os().rdbuf(&buf_); }
};

fdostream my_cout(1);
my_cout << "Hello," << " world!" << std::endl;

//假设fd处于阻塞模式
类fdostream:public std:：ostringstream{
typedef std：：ostream和（*manip_t）（std：：ostream和）；
结构fdbuf:public std:：stringbuf{
int fd_；
fdbuf（int-fd）：fd_（fd）{}
整数同步（）{
int r=：：write（fd_，str（）.data（），str（）.size（））；
str（std:：string（））；
返回（r>0）？0:-1；
} 
}布夫；
std:：ostream&os（）{return*this；}
公众：
fdostream（intfd）：buf_fd{os（）.rdbuf（&buf_fd）}
};
fdostream my_cout（1）；
如果您使用的是类UNIX操作系统，那么您可以使用
stringstream
适配器模拟所需的行为。这可能不是实现它的最佳方法，但是只要遇到
std:：endl
，就触发一个
write
调用

// Assume fd is in blocking mode
class fdostream : public std::ostringstream {
    typedef std::ostream & (*manip_t) (std::ostream &);
    struct fdbuf : public std::stringbuf {
        int fd_;
        fdbuf (int fd) : fd_(fd) {}
        int sync () {
            int r = ::write(fd_, str().data(), str().size());
            str(std::string());
            return (r > 0) ? 0 : -1;
        } 
    } buf_;
    std::ostream & os () { return *this; }
public:
    fdostream (int fd) : buf_(fd) { os().rdbuf(&buf_); }
};

fdostream my_cout(1);
my_cout << "Hello," << " world!" << std::endl;

//假设fd处于阻塞模式
类fdostream:public std:：ostringstream{
typedef std：：ostream和（*manip_t）（std：：ostream和）；
结构fdbuf:public std:：stringbuf{
int fd_；
fdbuf（int-fd）：fd_（fd）{}
整数同步（）{
int r=：：write（fd_，str（）.data（），str（）.size（））；
str（std:：string（））；
返回（r>0）？0:-1；
} 
}布夫；
std:：ostream&os（）{return*this；}
公众：
fdostream（intfd）：buf_fd{os（）.rdbuf（&buf_fd）}
};
fdostream my_cout（1）；
my_cout不清楚它是否适合您的情况，但您可能会将所有数据导入一个单独的工作进程，该进程在将数据转储到stdout之前聚合数据（具有自己的内部锁定）。
不清楚它是否适合您的情况参数，但是，您可能会将所有数据导入一个单独的工作进程，该进程在将数据转储到stdout之前聚合数据（具有自己的内部锁定）。
您知道C++11中是否有类似的内容吗？您知道C++11中是否有类似的内容吗？它可能不适合您的情况，但是，您可能会将所有数据导入一个单独的工作进程，该进程在将数据转储到stdout之前聚合数据（具有自己的内部锁定）。@reuben:在我的情况下，您的解决方案是最好的。如果你写了一个答案，我可以选择它作为被接受的答案。它可能不适合你的情况，但你可能会将所有数据转移到一个单独的工作进程，该进程在将数据转储到stdout之前聚合这些数据（具有自己的内部锁定）。@reuben:在我的情况下，你的解决方案是最好的。如果你写一个答案，我可以选择它作为接受的一个。