Correct way to declare/define custom cout-like obj

Question

I created my own std::cout-like object that writes both to std::cout and to a log file.

I'm currently defining it like this in a header file, but I'm getting unused variable warnings.

Header file <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;
}

Usage:

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

Should lo be static? Should lo be extern?

Kudos for explaining the correct way of declaring a cout-like object and showing how the main standard library implementations do it.

---

Edit: by cout-like object, I mean a global variable that is always available after including the corresponding header.

Answer 1

In one of my projects, I wrote wrapper for std::cout.

It looks something like this:

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

out_t out;

out << 1;

For complete code look for struct out in io.h

Answer 2

First, I'm not too sure what you mean be a cout-like object? Perhaps an std::ostream.

Anyway, the usual way of doing this is to use a filtering streambuf. Just write a streambuf which forwards to a log file, in addition to the usual place, and insert it where ever you want:

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

(This is C++11, but it shouldn't be hard to modify it for C++03.)

To use, you could use something like:

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

All output to std::cout will be logged until logger goes out of scope.

In practice, you'll likely use something more complicated than a filebuf for logging, since you may want to insert time stamps at the start of each line, or systematically flush at the end of each line. (Filtering streambufs can take care of those issues as well.)

Answer 3

std::cout is simply declared as follows:

namespace std {
    extern ostream cout;
}

It is a regular global variable; you can do the same thing yourself. Put an extern declaration of your variable in a header; then define the same variable in a source file and link it to your application:

// mylog.h
extern MyLog mylog;

// mylog.cpp
MyLog mylog(someparams);

Answer 4

Simply sending the input value right out to cout didn't work for me, because I wanted to add headers and info to the log output.

Also, I had my static Debug class in which to wrap the Log stream.

This is the way I managed to do this, I hope it's useful. I'm somehow a newbye to c++, so feel free to tell me if something is wrong :)

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

}

Answer 5

std::cout-like object that writes both to std::cout and to a log file

Maybe boost.iostreams would be sufficient?

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