Correct way to declare/define custom cout-like object

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.

`std::cout` is typically just an `std::ostream` of some sort, with some special logic to ensure that it is initialized early enough, and never destructed; at least one compiler I know uses special extensions to achieve this. But you usually don't need it; if worse comes to worse, you can use a singleton, and write `log() << ...`. — James Kanze, Jul 21 '13 at 16:55

score 7 · Accepted Answer · answered Jul 21 '13 at 18:35

7

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

answered Jul 21 '13 at 18:35

JohannesD

13,802
1
38
30

Thanks. I had tried declaring it `external` but forgot to define the variable in the source file. – Vittorio Romeo Jul 21 '13 at 19:22

score 1 · Answer 2 · answered Jul 21 '13 at 16:52

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.)

Thanks, but I desire a global variable that is always available, that's why I talked about `cout`-like object — Vittorio Romeo, Jul 21 '13 at 18:04
So you were concerned about the lifetime. That wasn't clear. In that case, the obvious solution is `std::ostream& logStream() { static std::ostream* theOneAndOnly = new MyStreamType; return *theOneAndOnly; }` There's a slight change in the syntax: you have to write `logStream() << ...`, rather than `logStream << ...`, but that's about it. (And you can still use the `LoggingOutputStreambuf` above in the stream you return from the `logStream`; it remains the simplest and most elegant way to push output to two separate destinations.) — James Kanze, Jul 21 '13 at 18:12

score 1 · Answer 3 · answered Jul 21 '13 at 17:33

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

I don't want to introduce any boost dependency, and I want a global variable like `cout` — Vittorio Romeo, Jul 21 '13 at 18:05

score 1 · Answer 4 · answered Nov 29 '17 at 16:31

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;

}

Leonid Volnitsky · Answer 5 · 2013-07-21T18:27:06.290

0

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

edited Jul 21 '13 at 18:27

answered Jul 21 '13 at 17:00

Leonid Volnitsky

8,854
5
38
53

This is closer to what I want - however I want a global instance of out that can be used without operator(), like `cout` does. – Vittorio Romeo Jul 21 '13 at 18:07
There is nothing that privets you to declare global `out` object. I've edited the code to show how to do it. – Leonid Volnitsky Jul 21 '13 at 18:26
@LeonidVolnitsky If I'm not using C++11, is it OK to replace `&&` with `&` in the code snippet you displayed? – synaptik Sep 19 '14 at 23:09

Correct way to declare/define custom cout-like object

5 Answers5

Linked