Cách chính xác để khai báo/xác định đối tượng cout tùy chỉnh giống như

Question

Tôi đã tạo đối tượng giống như std::cout giống như viết cả std::cout và vào tệp nhật ký.

Tôi hiện đang xác định nó như thế này trong tệp tiêu đề, nhưng tôi nhận được cảnh báo biến không sử dụng.

tập tin header <MyLib/Log.h>

static LOut { }; 
static LOut lo; 

template<typename T> inline LOut& operator<<(LOut& mLOut, const T& mValue) 
{ 
    std::string str{toStr(mValue)}; 
    std::cout << str; 
    getLogStream() << str; 
    return mLOut; 
} 

Cách sử dụng:

#include <MyLib/Log.h> 
... 
lo << "hello!" << std::endl; 

nên lo được static? Nên lo là extern?

Các yêu cầu để giải thích đúng cách khai báo đối tượng giống như cout và hiển thị cách triển khai thư viện chuẩn chính thực hiện.

---

Chỉnh sửa: bởi cout giống như đối tượng, tôi có nghĩa là biến toàn cục luôn có sẵn sau khi bao gồm tiêu đề tương ứng.

Answer 1

std::cout chỉ đơn giản là khai báo như sau:

namespace std { 
    extern ostream cout; 
} 

Nó là một biến toàn cầu thường xuyên; bạn có thể tự làm điều tương tự. Đặt một tuyên bố extern biến của bạn trong tiêu đề; sau đó xác định các biến tương tự trong một file nguồn và liên kết nó với ứng dụng của bạn:

// mylog.h 
extern MyLog mylog; 

// mylog.cpp 
MyLog mylog(someparams); 

Answer 2

Trước tiên, tôi không chắc chắn ý của bạn là đối tượng giống như đối tượng cout? Có thể là std::ostream.

Dù sao, cách thông thường để thực hiện việc này là sử dụng lọc streambuf. Chỉ cần viết một streambuf đó chuyển tiếp vào một tập tin nhật ký, ngoài chỗ cũ nhé, và chèn nó có bao giờ bạn muốn :

class LoggingOutputStreambuf : public std::streambuf 
{ 
    std::streambuf* myDest; 
    std::ofstreambuf myLogFile; 
    std::ostream* myOwner; 
protected: 
    int overflow(int ch) 
    { 
     myLogFile.sputc(ch); // ignores errors... 
     return myDest->sputc(ch); 
    } 
public: 
    LoggingOutputStreambuf(
      std::streambuf* dest, 
      std::string const& logfileName) 
     : myDest(dest) 
     , myLogFile(logfileName.c_str(), std::ios_base::out) 
     , myOwner(nullptr) 
    { 
     if (!myLogFile.is_open()) { 
      // Some error handling... 
     } 
    } 
    LoggingOutputStreambuf(
      std::ostream& dest, 
      std::string const& logfileName) 
     : LoggingOutputStreambuf(dest.rdbuf(), logfileName) 
    { 
     dest.rdbuf(this); 
     myOwner = &dest; 
    } 
    ~LoggingOutputStreambuf() 
    { 
     if (myOwner != nullptr) { 
      myOwner->rdbuf(myDest); 
     } 
    } 
}; 

(Đây là C++ 11, nhưng nó không phải là khó khăn . để sửa đổi nó cho C++ 03)

để sử dụng, bạn có thể sử dụng một cái gì đó như:

LoggingOutputStreambuf logger(std::cout); 
// ... 

Tất cả các đầu ra để std::cout sẽ được đăng nhập cho đến khi logger đi ra ngoài phạm vi.

Trong thực tế, bạn sẽ có khả năng sử dụng một cái gì đó phức tạp hơn một filebuf cho khai thác gỗ, kể từ khi bạn có thể muốn để chèn thời gian tem vào lúc bắt đầu của mỗi dòng, hoặc có hệ thống xả nước vào cuối mỗi dòng. (Lọc streambufs cũng có thể xử lý các vấn đề đó .)

Answer 3

Trong một trong số projects, tôi đã viết trình bao bọc cho std::cout.

Nó trông giống như sau:

struct out_t { 
    template<typename T> 
    out_t& 
    operator << (T&& x) { 
      std::cout << x; 
      // log << x; 
      return *this; 
    }; 
}; 

out_t out; 

out << 1; 

Đối với hoàn nhìn mã cho struct out trong io.h

Answer 4

std :: cout đối tượng giống như mà viết cả std :: cout và một bản ghi file

Có lẽ boost.iostreams là đủ?

#include <iostream> 
#include <fstream> 
#include <boost/iostreams/stream.hpp> 
#include <boost/iostreams/tee.hpp> 

namespace io = boost::iostreams; 
int main() 
{ 
    typedef io::tee_device<std::ostream, std::ofstream> teedev; 
    typedef io::stream<teedev> LOut; 
    std::ofstream outfile("test.txt"); 
    teedev logtee(std::cout, outfile); 
    LOut mLOut(logtee); 
    mLOut << "hello!" << std::endl; 
} 

Answer 5

Đơn giản chỉ cần gửi các giá trị đầu vào đúng ra cout không làm việc cho tôi, vì tôi muốn thêm tiêu đề và thông tin để đăng nhập đầu ra.

Ngoài ra, tôi đã có lớp gỡ lỗi tĩnh của mình để bao bọc luồng nhật ký.

Đây là cách tôi quản lý để làm điều này, tôi hy vọng nó hữu ích. Tôi bằng cách nào đó một lời tạm biệt với c + +, do đó, cảm thấy tự do để cho tôi biết nếu một cái gì đó là sai :)

#include <iostream> 
#include <sstream> 
#include <ostream> 

enum class DebugLevel { 
    INFO, 
    WARNING, 
    ERROR 
}; 

class Debug { 

    public: 

     /* other Debug class methods/properties 
      ... 
     */ 

     // out stream object 
     static struct OutStream { 

       std::ostringstream stream; 
       DebugLevel level = DebugLevel::INFO; 

      public: 

       // here you can add parameters to the object, every line log 
       OutStream& operator()(DebugLevel l) { 
        level = l; 
        return *this; 
       } 

       // this overload receive the single values to append via << 
       template<typename T> 
       OutStream& operator<<(T&& value) { 
        stream << value; 
        return *this; 
       } 

       // this overload intercept std::endl, to flush the stream and send all to std::cout 
       OutStream& operator<<(std::ostream& (*os)(std::ostream&)) { 

        // here you can build the real console log line, add colors and infos, or even write out to a log file 
        std::cout << __TIME__ << " [" << (int)level << "] " << stream.str() << os; 

        stream.str(""); // reset the string stream 
        level = DebugLevel::INFO; // reset the level to info 
        return *this; 
       } 

     } Log; 

}; 

Debug::OutStream Debug::Log; // need to be instantiaded only because I use a static Debug class 

int main() { 

    Debug::Log(DebugLevel::ERROR) << "Hello Log! " << 2 << " " << __FUNCTION__ << std::endl; 

    Debug::Log << "Hello Log! " << 0xFA << std::endl; // NB: this way the debugLevel is default 

    return 0; 

}