9

我创建了我自己的类似std::cout对象，该对象既可以写入日志文件，也可以写入std::cout日志文件。

我目前在头文件中这样定义它，但是我收到了未使用的变量警告。

头文件<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;
}

用法：

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

应该lo是static？应该lo是extern？

感谢解释声明cout类对象的正确方法并展示主要标准库实现如何做到这一点。

编辑：通过cout-like 对象，我的意思是一个全局变量，在包含相应的标头后始终可用。

4

5 回答 5

7

std::cout简单地声明如下：

namespace std {
    extern ostream cout;
}

它是一个常规的全局变量；你可以自己做同样的事情。将extern变量声明放在标题中；然后在源文件中定义相同的变量并将其链接到您的应用程序：

// mylog.h
extern MyLog mylog;

// mylog.cpp
MyLog mylog(someparams);
于 2013-07-21T18:35:20.457 回答
1

写入 std::cout 和日志文件的类 std::cout 对象

也许boost.iostreams就足够了？

#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;
}
于 2013-07-21T17:33:27.997 回答
1

首先，我不太确定你的意思是什么是cout-like 对象？也许一个std::ostream.

无论如何，这样做的通常方法是使用过滤流缓冲区。除了通常的位置之外，只需编写一个转发到日志文件的 streambuf，然后将其插入到您想要的任何位置：

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

（这是 C++11，但为 C++03 修改它应该不难。）

要使用，您可以使用以下内容：

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

所有输出都std::cout将被记录，直到logger超出范围。

在实践中，您可能会使用比 a 更复杂的东西 filebuf来记录日志，因为您可能希望在每行的开头插入时间戳，或者在每行的末尾系统地刷新。（过滤流缓冲区也可以解决这些问题。）

于 2013-07-21T16:52:15.060 回答
1

简单地将输入值直接发送到 cout 对我来说不起作用，因为我想将标题和信息添加到日志输出中。

另外，我有我的静态调试类来包装日志流。

这是我设法做到这一点的方式，我希望它有用。我不知何故是 C++ 的新手，所以如果有什么问题，请随时告诉我 :)

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

}
于 2017-11-29T16:31:49.527 回答
0

在我的一个项目中，我为std::cout.

它看起来像这样：

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

out_t out;

out << 1;

有关完整代码，请struct out在io.h

于 2013-07-21T17:00:04.083 回答