Extending std::cout

There are multiple concerns here which do require different approaches. Some of the description also seems that the actual desire isn't quite clear. The most problematic requirement is that a newline needs to be inserted apparently at the end of a statement. That's certainly doable but effectively does require a temporary being around.

Before going there I want to point out that most other languages offering a print-line(....) construct delineate what is going onto a line using a function call. There is no doubt where the newline goes. If C++ I/O would be created now I'd be quite certain that it would be based on a variadic (not vararg) function template. This way print something at the end of the expression is trivial. Using a suitable manipulator at the end of the line (although probably not std::endl but maybe a custom nl) would be an easy approach.

The basics of adding a newline at the end of expression would be using a destructor of a suitable temporary object to add it. The straight forward way would be something like this:

#include <iostream> class newline_writer : public std::ostream { bool need_newline = true; public: newline_writer(std::streambuf* sbuf) : std::ios(sbuf), std::ostream(sbuf) { } newline_writer(newline_writer&& other) : newline_writer(other.rdbuf()) { other.need_newline = false; } ~newline_writer() { this->need_newline && *this << '\n'; } }; newline_writer writeline() { return newline_writer(std::cout.rdbuf()); } int main() { writeline() << "hello, " << "world"; } 

This works reasonable nice. The notation in the question doesn't use a function call, though. So, instead of writing

writeline() << "hello"; 

it seems necessary to write

writeline << "hello"; 

instead and still add a newline. This complicates matters a bit: essentially, writeline now needs to be an object which somehow causes another object to jump into existence upon use so the latter can do its work in the destructor. Using a conversion won't work. However, overloading an output operator to return a suitable object does work, e.g.:

class writeliner { std::streambuf* sbuf; public: writeliner(std::streambuf* sbuf): sbuf(sbuf) {} template <typename T> newline_writer operator<< (T&& value) { newline_writer rc(sbuf); rc << std::forward<T>(value); return rc; } newline_writer operator<< (std::ostream& (*manip)(std::ostream&)) { newline_writer rc(sbuf); rc << manip; return rc; } } writeline(std::cout.rdbuf()); int main() { writeline << "hello" << "world"; writeline << std::endl; } 

The primary purpose of the overloaded shift operators is to create a suitable temporary object. They don't try to mess with the content of the character stream. Personally, I'd rather have the extra parenthesis than using this somewhat messy approach but it does work. What is kind of important is that the operator is also overloaded for manipulators, e.g., to allow the second statement with std::endl. Without the overload the type of endl can't be deduce.

The next bit is writing the prefix and mixing multiple streams. The important bit here is to realize that you'd want to one of two things:

1. Immediately write the characters to a common buffer. The buffer is most like just another stream buffer, e.g., the destination std::streambuf.
2. If the character should be buffered locally in separate stream buffers, the corresponding streams need be flushed in a timely manner, e.g., after each insertion (by setting the std::ios_base::unitbuf bit) or, latest, at the end of the expression, e.g., using an auxiliary class similar to the newline_writer.

Passing through the characters immediately is fairly straight forward. The only slight complication is to know when to write a prefix: upon the first non-newline, non-carriage-return return after a newline or a carriage return (other definitions are possibly and should be easily adaptable). The important aspect is that stream buffer doesn't really buffer but actually passes through the character to the underlying [shared] stream buffer:

class prefixbuf : public std::streambuf { std::string prefix; bool need_prefix = true; std::streambuf* sbuf; int overflow(int c) { if (c == std::char_traits<char>::eof()) { return std::char_traits<char>::not_eof(c); } switch (c) { case '\n': case '\r': need_prefix = true; break; default: if (need_prefix) { this->sbuf->sputn(this->prefix.c_str(), this->prefix.size()); need_prefix = false; } } return this->sbuf->sputc(c); } int sync() { return this->sbuf->pubsync(); } public: prefixbuf(std::string prefix, std::streambuf* sbuf) : prefix(std::move(prefix)), sbuf(sbuf) { } }; 

The remaining business is to set up the relevant objects in the Console namespace. However, doing so is rather straight forward:

namespace Console { prefixbuf errorPrefix("ERROR", std::cout.rdbuf()); std::ostream Write(std::cout.rdbuf()); writeliner WriteLine(std::cout.rdbuf()); std::ostream Error(&errorPrefix); writeliner ErrorLine(&errorPrefix); } 

I except that the approach adding the newline creates a custom type I think that matches the original goes. I don't think the temporary object can be avoided to automatically create a newline at the end of a statement.

All that said, I think you should use C++ idioms and not try to replicate some other language in C++. The way to choose whether a line end in newline or not in C++ is to write, well, a newline where one should appear potentially by way of a suitable manipulator.