#include <crtdbg.h>

namespace debug
{
  namepspace utility
  {
    template<class T>
    void dprintf(const char* fmt, T t)
    {
      _CrtDbgReport(_CRT_WARN,NULL,0,NULL, fmt, t);
    }

    inline void dprints(const char* s)
    {
      dprintf("%s", s);
    }
    inline void dprints(const wchar_t* s)
    {
      dprintf("%S", s);
    }
    inline void dprintc(char c)
    {
      dprintf("%c", c);
    }
    inline void dprintc(wchar_t c)
    {
      wchar_t s[2] = { c, 0 };
      dprints(s);
    }
  }//debug::utility
}//debug

#include <windows.h> // OutputDebugString
#include <malloc.h> // _alloca
#include <stdlib.h> // mbs <-> wcs

namespace debug
{
  namepspace utility
  {
#ifndef UNICODE
    void dprints(const char* s, int n=0)
    {
      OutputDebugStringA(s);
    }
    void dprints(const wchar_t* s, int n=1024)
    {
      wchar_t* buf;
      buf = alloca(n*sizeof(wchar_t)):
      mbstowcs(buf, s, 1024);
      dprints(buf);
    }
#else
    void dprints(const wchar_t* s, int n=0)
    {
      OutputDebugStringW(s);
    }
    void dprints(const char* s, int n=1024)
    {
      char* buf;
      buf = alloca(n):
      wcstombs(buf, s, 1024);
      dprints(buf);
    }
#endif

    void dprintc(char c)
    {
      char buf[2] = { c, 0 };
      dprints(buf, 2);
    }
    void dprintc(wchar_t c)
    {
      wchar_t buf[2] = { c, 0 };
      dprints(buf, 8); // а вдруг в текущей локали выбран utf-7 %)
    }
  }//debug::utility
}//debug

#include <streambuf>

namespace debug
{
  using namespace std;

  template<class E, class T=char_traits<E> >
  class basic_debugbuf : public basic_streambuf<E,T>
  {
  public:
    // Dinkumware STL для VC7
    typedef basic_debugbuf<_Elem, _Traits> _Myt;
    typedef basic_streambuf<_Elem, _Traits> _Mysb;
    typedef codecvt<_Elem, char, typename _Traits::state_type> _Cvt;

    typedef E char_type;
    typedef T traits_type;
    typedef typename T::int_type int_type;
    typedef typename T::pos_type pos_type;
    typedef typename T::off_type off_type;

  protected:
    virtual streamsize xsputn(char_type const* s, streamsize n)
    {
      dprints(s); // мы не без оснований полагаем, что s - это нуль-терминированная строка
    }
    virtual int_type overflow(int_type c = traits_type::eof())
    {
      if(c != traits_type::eof()) dprintc(c);
      return c;
    }
  };

  typedef basic_debugbuf<char> debugbuf;
  typedef basic_debugbuf<wchar_t> wdebugbuf;
}//namespace debug

#include <ios>
#include <iosfwd>

... не забудем включить код нашего debugbuf

namespace debug
{
  using namespace std;

  template<class E, class T=char_traits<E> >
  class basic_debugstream : public basic_ostream<E,T>
  {
  private:
    basic_streambuf<E,T>* oldbuf;
    basic_debugbuf<E,T> newbuf;
  public:
    basic_debugstream() : basic_ostream<E,T>(_Noinit)
    {
      oldbuf = rdbuf(&newbuf);
    }
    ~basic_debugstream()
    {
      rdbuf(oldbuf);
    }
  };

  typedef basic_debugstream<char> debugstream;
  typedef basic_debugstream<wchar_t> wdebugstream;

};//debug

#include <iostream>
#include <cassert>

... включим код debugbuf

namespace debug
{
  using namespace std;

  template<class E, class T=char_traits<E> >
  class basic_debugsentry
  {
    basic_ostream<E,T>* ostr;
    basic_streambuf<E,T>* oldbuf;
    basic_debugbuf<E,T> newbuf;
  public:
    basic_debugsentry(basic_ostream<E,T>* os) : ostr(os)
    {
      assert(os != NULL);
      oldbuf = os->rdbuf(&newbuf);
    }
    ~basic_debugsentry()
    {
      os->rdbuf(oldbuf);
    }
  };

  typedef basic_debugsentry<char> debugsentry;
  typedef basic_debugsentry<wchar_t> wdebugsentry;

  template<ostream* ostr, wostream* wostr>
  class debugsentry_streams
  {
    debugsentry cs;
    wdebugsentry ws;
  public:
    debugsentry_streams() : cs(ostr), ws(wostr) {}
  };

  typedef debugsentry_streams<cout,wcout> debugsentry_cout;
  typedef debugsentry_streams<clog,wclog> debugsentry_clog;
  typedef debugsentry_streams<cerr,wcerr> debugsentry_cerr;

};//debug

#include "dbgout.h"

int main()
{
  cout << "hello, console." << endl;
  cdbg << "hello, debugger." << endl;

  debugsentry_cout guard__;

  cout << "hello, debugger" << endl;
}

namespace debug
{

  template<class E, class T=char_traits<E> >
  class basic_debugout
  {
  public:
    static basic_debugstream<E,T> instance;
  };

  template<class E, class T=char_traits<E> >
  basic_debugstream<E,T> basic_debugout<E,T>::instance;

  typedef basic_debugout<char> debugout;
  typedef basic_debugout<wchar_t> wdebugout;

  debugstream& cdbg = debugout::instance;
  debugstream& wcdbg = wdebugout::instance;

}//debug

void dprintf(const char* fmt, ...)
{
  char buffer[2049]; buffer[0]=0;
  va_list args;
  va_start ( args, fmt );
  int len = _vsnprintf( buffer, 2048, fmt, args );
  va_end ( args );
  OutputDebugString(buffer);
}