How to open custom I/O streams from within a C++ program?

Question

It is well known that there are three default I/O streams which are mapped to predefined objects in the standard library:

• 0: std::istream std::cin
• 1: std::ostream std::cout
• 2: std::ostream std::cerr and std::ostream std::clog

However, from within (e.g.) a bash script you can create additional streams (3,4,...).

So, can you create an extra output stream with the descriptor 3 and bind it to an std::ostream custom object? If so, how? std::ofstream doesn't do the trick as it would create a file with the name "3" which is not what I want.

---

Edit: It doesn't have to be portable. It suffices if it works on POSIX.

Answer 1

It is not possible if you need your program to be portable. The C++ 11 Standard does not specify a unified way of doing that.

However, you can define your own output stream buffer which overrides the overflow() and xsputn() virtual functions and writes each character or sequence of characters to the stream with the specified descriptor using system-specific API.

Something along these lines:

class my_ostream_buf : public std::streambuf
{

public:

    my_ostream_buf(int fd) : _fd(fd) { }

protected:

    virtual int_type overflow (int_type c)
    {
        if (c != EOF)
        {
            char ch = c;
            if (write(_fd, &ch, 1) != 1)
            {
                return EOF;
            }
        }

        return c;
    }

    // This is not strictly necessary, but performance is better if you
    // write a sequence of characters all at once rather than writing
    // each individual character through a separate system call.
    virtual std::streamsize xsputn(const char* s, std::streamsize num)
    {
        return write(_fd, s, num);
    }

private:

    int _fd = 0;    

};

And this is how you would use it:

using namespace std;

int main()
{
    int fd = ...; // Any file descriptor
    my_ostream_buf buf(fd);

    ostream os(&buf); // Take care of the lifetime of `buf` here, or create your
                      // own class that derives from ostream and encapsulates an
                      // object of type my_ostream_buf

    os << "Hello" << endl;
}

Answer 2

There's nothing provided for this in the standard. In a good implementation of IOStream, there should be some additional, implementation specific constructors for std::filebuf, which take a system file descripter (whose type will depend on the system), and create a filebuf from that. If not, you'll have to create your own streambuf. This can be more or less difficult, depending on what you need: if you're just need a simple, uni-directional stream (read or write, but not both), with no support for seeking and no code translation on input, it's relatively simple. (But you still have to be familiar with the system level requests, like read or write.) If you want to support everything that filebuf does, it is significantly more complicated.

EDIT:

Just thought I'd add an example. Since you speak of bash, I'll suppose Unix:

class FdStreambuf : public std::streambuf
{
    int myFd;
    char buffer[1024];

    bool writeBuffer()
    {
        int len = pptr() - pbase();
        return len == 0 || write( myFd, pptr(), len ) == len;
    }

protected:
    int overflow( int ch )
    {
        int results = ch == traits::eof() ? 0 : ch;
        if ( pbase() != NULL ) {
            if ( ! writeBuffer() ) {
                results = traits::eof();
            }
        }
        setp( buffer, buffer + sizeof( buffer ) );
        sputc( ch );
        return ch;
    }

    int sync()
    {
        return writeBuffer() ? 0 : -1;
    }

public:
    FdStreambuf( int fd ) : myFd( fd ) {}
    int close()
    {
        sync();
        return ::close( myFd );
    }
};

class FdOStream : private FdStreambuf, public std::ostream
{
public:
    FdOStream( int fd )
        : FdStreambuf( fd )
        , std::ostream( this )
    {
    }
    void close()
    {
        if ( FdStreambuf::close() != 0 ) {
            setstate( std::ios_base::badbit );
        }
    }
};

(I think that's all that's necessary, but it's possible I've forgotten something.)

Answer 3

I combined Andy's and James's answer and this is what I got (in case somebody needs this)

Streams.h

#pragma once

#include <ostream>
#include <unistd.h>

namespace util {
  class StreamWrapperImpl : public std::ostream {
    private:
      typedef std::streambuf* OwnedBufPtr;
      OwnedBufPtr const buf;
    public:
      StreamWrapperImpl(OwnedBufPtr buf)
      : std::ostream(buf)
      , buf(buf)
      {}
      virtual ~StreamWrapperImpl() {
        delete buf;
      }
  };
  template <typename Buf>
  class StreamWrapper : public StreamWrapperImpl {
    public:
      StreamWrapper()
      : StreamWrapperImpl(new Buf())
      {}
      template <typename Arg>
      StreamWrapper(Arg arg) // this could use some perfect forwarding in C++11
      : StreamWrapperImpl(new Buf(arg))
      {}
  };

  class FdStreamBuf : public std::streambuf {
    private:
      int fd;
    protected:
      virtual int_type overflow(int_type c) {
        if (c != EOF) {
          char const ch = c;
          if (write(fd, &ch, 1) != 1)
            return EOF;
        }
        return c;
      }
      virtual std::streamsize xsputn(char const* s, std::streamsize num) {
        return write(fd, s, num);
      }
    public:
      FdStreamBuf(int fd)
      : fd(fd)
      {
      }
  };
}