How can I call a member function via a stream insertion operator?

Question

Using gcc 4.8 with C++11 enabled, I have a class like this:

class OutStream {
public:
    OutStream& operator<<(const char* s);
    OutStream& operator<<(int n);
    OutStream& operator<<(unsigned int n);
    // ...
    OutStream& vformat(const char* fmt, __VALIST args);
    OutStream& format(const char* fmt, ...);
};

When I use this class by calling the operators directly, it works as I expected:

OutStream out;
out.operator<<(1).format(" formatted %04X ", 2).operator<<("3\n");

Output:

1 formatted 0002 3

Now, I'd like to got the same output but by using the << streaming notation, maybe like this:

OutStream out;
out << 1 << format(" formatted %04X ", 2) << "3\n";

Of course, this wouldn't compile, because there was no such operator for streaming my OutStream.format() method.

There might be a solution where format() was a free function which returns a string, but this needs to first write all the output of format() into a buffer. I need a solution without std::string or some other heap or buffer usage—at best a solution which creates nearly the same code as when calling the operators directly.

Any suggestions?

Edit, 2014-10-20:

• For better understanding my requirements: I'm on bare metal embedded development using gcc-arm-embedded gcc cross toolchain.
• I need to apply the solution for some different embedded target systems (most are Cortex-M0/M3/M4). Some of them have very limited resources (Ram & Flash) and a part of my target systems must run without any heap usage.
• For some reasons, I'm not using Stl iostream. However, the iostream tag has been set by seh edit; I'd keep it set because of thematic match and a found solution for my problem may also be applicable for Stl iostream.

Answer 1

Using C++14 index_sequence (There are a million different implementations on SO):

template <typename...Ts>
class formatter {
    const char* fmt_;
    std::tuple<Ts...> args_;

    template <std::size_t...Is>
    void expand(OutStream& os, std::index_sequence<Is...>) && {
        os.format(fmt_, std::get<Is>(std::move(args_))...);
    }

public:
    template <typename...Args>
    formatter(const char* fmt, Args&&...args) :
        fmt_{fmt}, args_{std::forward<Args>(args)...} {}

    friend OutStream& operator << (OutStream& os, formatter&& f) {
        std::move(f).expand(os, std::index_sequence_for<Ts...>{});
        return os;
    }
};

template <typename...Args>
formatter<Args&&...> format(const char* fmt, Args&&...args) {
    return {fmt, std::forward<Args>(args)...};
}

DEMO

The compiler should easily be able to inline the operation of the formatter and elide the temporary object. Indeed this function:

void test_foo() {
    OutStream out;
    out << 1 << format(" formatted %04X ", 2) << "3\n";
}

results in the assembly (g++ 4.9.0 -std=c++1y -O3 targeting x64):

.LC0:
    .string " formatted %04X "
.LC1:
    .string "3\n"
test_foo():
    pushq   %rbx
    movl    $1, %esi
    subq    $16, %rsp
    leaq    15(%rsp), %rdi
    call    OutStream::operator<<(int)
    movl    $2, %edx
    movl    $.LC0, %esi
    movq    %rax, %rbx
    movq    %rax, %rdi
    xorl    %eax, %eax
    call    OutStream::format(char const*, ...)
    movq    %rbx, %rdi
    movl    $.LC1, %esi
    call    OutStream::operator<<(char const*)
    addq    $16, %rsp
    popq    %rbx
    ret

so everything is properly inlined; there is no trace of the formatter in the produced code.

Answer 2

There are three extension points for class std::basic_ostream and its operator<< that look relevant here:

• "Insert" a function that takes and returns a std::ios_base&.
• "Insert" a function that takes and returns a std::basic_ios<C, T>&.
• "Insert" a function that takes and returns a std::basic_ostream&.

It's unfortunate that all three operate on function pointers, and not std::function instances, which makes it harder to supply a closure. In your case, you'd like to supply the format string—and maybe the format arguments—a la std::setw().

You can find a discussion of how to implement these manipulators in Cay Horstmann's well-aged essay Extending the iostream Library. In particular, look at section 3, "Manipulators", to see how you can return an object from your format() function that serves as a closure, and write an operator<<() function for that object.

Doing so will involve some extra copying if you want to capture temporary values in your closure, and you may have difficulty capturing a variadic argument list. Start with a simple interface (maybe taking just one argument), make sure it writes to the target stream, and build up from there.

Answer 3

Try the following:

OutStream out;
(out << 1).format(" formatted %04X ", 2) << "3\n";

Answer 4

Consider using GNU's autosprintf. It's very small. No, really. It's essentially a wrapper around vasprintf. All autosprintf needs is an std::string implementation and your usual freestanding C headers. Here is the header file and documentation. Example of how you could use it:

OutStream out;
out << 1 << gnu::autosprintf(" formatted %04X ", 2) << "3\n";

(Actually if you use fixed-sized strings, you could modify this to avoid any usage of std::string at all. Of course, there's still the assumption that you have implemented vasprintf and some form of heap allocation.)