我一直在谷歌搜索，但我找不到一个简单的答案。它应该很简单，就像 STL 通常一样。
我想定义从 std::ostream 公开继承的 MyOStream。假设每次将某些内容写入我的流时，我都想调用 foo() 。
class MyOStream : public ostream {
public:
...
private:
void foo() { ... }
}
我知道ostream的公共接口是非虚拟的，那怎么办呢？我希望客户能够在 MyOStream 上同时使用 operator<< 和 write() 和 put() 并使用我的课程的扩展能力。
我一直在思考如何做同样的事情，我发现这实际上并不难。基本上只是子类化 ostream 和 streambuf 对象，并以自身作为缓冲区构造 ostream。对于发送到流的每个字符，都会调用 std::streambuf 的虚拟溢出（）。为了适合你的例子，我只是做了一个 foo() 函数并调用它。
#include <iostream>
struct Bar : private std::streambuf , public std::ostream
{
Bar() : std::ostream(this) {}
private:
int overflow(int c) override
{
foo(c);
return 0;
}
void foo(char c)
{
std::cout.put(c);
}
};
int main()
{
Bar b;
b<<"Look a number: "<<std::hex<<29<<std::endl;
return 0;
}
编辑：旧代码使用了错误的初始化顺序。尽管它没有可见的副作用，但应该在将 streambuf 对象传递给 ostream 对象之前对其进行初始化。由于 C++ 从左到右初始化父母，我将 std::streambuf 移到左侧以使代码正确。
编辑：我将代码更改为私下继承 std::streambuf 以保持接口清洁并保持类封装。
不幸的是，这不是一个简单的问题。您应该派生的类是basic_类，例如basic_ostream. 但是，从流派生可能不是您想要的，您可能希望从流缓冲区派生，然后使用此类实例化现有的流类。
整个领域都很复杂，但是有一本关于它的优秀书籍Standard C++ IOStreams and Locales，我建议你在继续阅读之前先看看。
实现类似效果的另一个工作技巧是使用模板和合成
class LoggedStream {
public:
LoggedStream(ostream& _out):out(_out){}
template<typename T>
const LoggedStream& operator<<(const T& v) const {log();out << v;return *this;}
protected:
virtual void log() = 0;
ostream& out;
};
class Logger : LoggedStream {
void log() { std::cerr << "Printing" << std::endl;}
};
int main(int,char**) {LoggedStream(std::cout) << "log" << "Three" << "times";}
我不知道这是否是正确的解决方案，但我以这种方式从 std::ostream 继承。它使用从 std::basic_streambuf 继承的缓冲区，一次获取 64 个字符（如果刷新则更少），并将它们发送到一个通用的 putChars() 方法，在该方法中完成数据的实际处理。它还演示了如何提供用户数据。
#include <streambuf>
#include <ostream>
#include <iostream>
//#define DEBUG
class MyData
{
//example data class, not used
};
class MyBuffer : public std::basic_streambuf<char, std::char_traits<char> >
{
public:
inline MyBuffer(MyData data) :
data(data)
{
setp(buf, buf + BUF_SIZE);
}
protected:
// This is called when buffer becomes full. If
// buffer is not used, then this is called every
// time when characters are put to stream.
inline virtual int overflow(int c = Traits::eof())
{
#ifdef DEBUG
std::cout << "(over)";
#endif
// Handle output
putChars(pbase(), pptr());
if (c != Traits::eof()) {
char c2 = c;
// Handle the one character that didn't fit to buffer
putChars(&c2, &c2 + 1);
}
// This tells that buffer is empty again
setp(buf, buf + BUF_SIZE);
return c;
}
// This function is called when stream is flushed,
// for example when std::endl is put to stream.
inline virtual int sync(void)
{
// Handle output
putChars(pbase(), pptr());
// This tells that buffer is empty again
setp(buf, buf + BUF_SIZE);
return 0;
}
private:
// For EOF detection
typedef std::char_traits<char> Traits;
// Work in buffer mode. It is also possible to work without buffer.
static const size_t BUF_SIZE = 64;
char buf[BUF_SIZE];
// This is the example userdata
MyData data;
// In this function, the characters are parsed.
inline void putChars(const char* begin, const char* end){
#ifdef DEBUG
std::cout << "(putChars(" << static_cast<const void*>(begin) <<
"," << static_cast<const void*>(end) << "))";
#endif
//just print to stdout for now
for (const char* c = begin; c < end; c++){
std::cout << *c;
}
}
};
class MyOStream : public std::basic_ostream< char, std::char_traits< char > >
{
public:
inline MyOStream(MyData data) :
std::basic_ostream< char, std::char_traits< char > >(&buf),
buf(data)
{
}
private:
MyBuffer buf;
};
int main(void)
{
MyData data;
MyOStream o(data);
for (int i = 0; i < 8; i++)
o << "hello world! ";
o << std::endl;
return 0;
}
组合，而不是继承。您的类包含“包装”一个 ostream&，并转发给它（在调用 foo() 之后）。