Làm thế nào để kế thừa từ std :: ostream?

Question

Tôi đã googling xung quanh và tôi chỉ không thể tìm thấy một câu trả lời đơn giản này. Và nó phải đơn giản, như STL nói chung là.

Tôi muốn xác định MyOStream kế thừa công khai từ std :: ostream. Giả sử tôi muốn gọi foo() mỗi khi có nội dung nào đó được ghi vào luồng của tôi.

class MyOStream : public ostream { 
public: 
    ... 
private: 
    void foo() { ... } 
} 

Tôi hiểu rằng giao diện công khai của luồng không phải là ảo, vậy làm thế nào nó có thể được thực hiện? Tôi muốn khách hàng có thể sử dụng cả hai nhà điều hành < < và viết() và đặt() trên MyOStream và sử dụng khả năng mở rộng của lớp học của tôi.

Answer 1

Thật không phải là một câu hỏi đơn giản, thật không may. Các lớp học bạn nên lấy được là các lớp học basic_, chẳng hạn như basic_ostream. Tuy nhiên, dẫn xuất từ ​​một luồng có thể không phải là những gì bạn muốn, bạn có thể muốn lấy ra từ một bộ đệm luồng thay vào đó, và sau đó sử dụng lớp này để khởi tạo một lớp luồng hiện có.

Toàn bộ khu vực là phức tạp, nhưng có một cuốn sách tuyệt vời về nó Standard C++ IOStreams and Locales, mà tôi đề nghị bạn hãy xem trước khi đi thêm nữa.

Answer 2

Thành phần, không phải thừa kế. Lớp học của bạn chứa "kết thúc tốt đẹp" một ostream & và chuyển tiếp đến nó (sau khi gọi foo()).

Answer 3

Tôi không biết đây có phải là giải pháp đúng hay không, nhưng tôi được thừa hưởng từ std :: ostream theo cách này. Nó sử dụng một bộ đệm được thừa kế từ std :: basic_streambuf và nhận được 64 ký tự cùng một lúc (hoặc ít hơn nếu được flushed) và gửi chúng đến một phương thức putChars() chung nơi xử lý dữ liệu thực tế được thực hiện. Nó cũng thể hiện cách cung cấp dữ liệu người dùng.

Live Example

#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; 
} 

Answer 4

làm việc khác hack để đạt được một hiệu ứng tương tự là sử dụng mẫu và thành phần

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";} 

Answer 5

tôi đã quay quanh đầu tôi làm thế nào để làm điều tương tự và tôi phát hiện ra nó thực sự không phải là khó. Về cơ bản chỉ phân lớp ostream và các đối tượng streambuf, và xây dựng ostream với chính nó như là bộ đệm. tràn ảo() từ std :: streambuf sẽ được gọi cho mọi ký tự được gửi tới luồng. Để phù hợp với ví dụ của bạn tôi chỉ cần thực hiện một hàm foo() và gọi nó.

struct Bar : std::ostream, std::streambuf 
{ 
    Bar() : std::ostream(this) {} 

    int overflow(int c) 
    { 
     foo(c); 
     return 0; 
    } 


    void foo(char c) 
    { 
     std::cout.put(c); 

    } 
}; 

void main() 
{ 
    Bar b; 
    b<<"Look a number: "<<std::hex<<29<<std::endl; 
} 

oh và bỏ qua thực tế là chức năng chính không phải là chức năng chính thực sự. Trong một không gian tên được gọi từ nơi khác, p