std::cout << quotes("\"")
    << std::string("Hello world!") << std::endl
    << std::string("A test") << std::endl;

"Hello world!"
"A test"

template <class T> struct quoted_t
{
    T const &v_;
    explicit quoted_t(T const &v) : v_(v) {}
};

template<class T> quoted_t<T> quoted(T const& t)
{ return quoted_t<T>(t); }

ident i;
s << i << quoted("level 0") << endl
  << i << quoted("level 0 again") << endl
  << ++i << quoted("level 1") << endl
  << --i << quoted("level 0") << endl;

1. Слишком общий, такой гибкости мне не надо, т.к. обрабатывать нужно только строки. Ну, это просто исправить.
   
2. Всё-таки используется дополнительный класс-обёртка, а его очень хотелось бы избежать. Слишком велик шанс того, что пользователь класса влепит std::string вместо quoted (а то и строковый литерал). Нельзя ли обойтись без дополнительного класса?

#include <iostream>
#include <string>

class quoted : public std::string {
        public:
                explicit quoted(const char * oString) : std::string(oString) { }
                explicit quoted(const std::string & oString) : std::string(oString) { }
};

std::ostream & operator<<(std::ostream & oStream, const quoted & oString) {
        using std::string;

        string s(oString.c_str());

        string::size_type i = static_cast<string::size_type>(0);

        while ((i = s.find('\"', i)) != string::npos) {
                s.insert(i, 1, '\\');
                i += 2;
        }

        oStream << "\"" << s << "\"";
        return oStream;
}

std::fstream s("qwe.txt");

s << setindent(2) // Каждая последующая новая строка должна быть отбита 2мя tab-ами.
  << "test" << 123 << std::endl
  << "yet another test" << 567 << std::endl
  << setindent(1) // Каждая последующая новая строка должна быть отбита 1м tab-ом.
  << "test once again" << 890 << std::endl;

        "test" 123
        "yet another test" 567
    "test once again" 890

string val = "_value_";
s << "prefix" << val << "suffix";

> #include <iostream>
> #include <string>
> 
> class quoted : public std::string {
>        public:
>                explicit quoted(const char * oString) : std::string(oString) { }
>                explicit quoted(const std::string & oString) : std::string(oString) { }
> };
> 
> std::ostream & operator<<(std::ostream & oStream, const quoted & oString) {
>        using std::string;
> 
>        string s(oString.c_str());
> 
>        string::size_type i = static_cast<string::size_type>(0);
> 
>        while ((i = s.find('\"', i)) != string::npos) {
>                s.insert(i, 1, '\\');
>                i += 2;
>        }
> 
>        oStream << "\"" << s << "\"";
>        return oStream;
> }
>

> std::fstream s("qwe.txt");
> 
> s << setindent(2) // Каждая последующая новая строка должна быть отбита 2мя tab-ами.
>  << "test" << 123 << std::endl
>  << "yet another test" << 567 << std::endl
>  << setindent(1) // Каждая последующая новая строка должна быть отбита 1м tab-ом.
>  << "test once again" << 890 << std::endl;
>

> "test" 123
> "yet another test" 567
> "test once again" 890
>

string val = "_value_";
s << "prefix" << val << "suffix";

> string val = "_value_";
> s << "prefix" << val << "suffix";
>

> Это я уже понял ещё при написании прошлого ответа на Ваш пост. Сейчас уже интересна сама возможность реализовать подобное. Даже с наследованием ума не приложу, как можно добиться результата. Ведь наследоваться-то нужно от ostream, а получить функционал в классах stringstream и fstream.

struct current_tabbing : public std::locale::facet
{
    unsigned n_;
    current_tabbing(std::size_t refs, unsigned n) : std::locale::facet(refs), n_(n) {}
};

std::ostream& operator<<(ostream& s, const setindent& v)

{

    if (std::has_facet<current_tabbing>(s.getloc()))

        std::use_facet<current_tabbing>(s.getloc()).n_ = v.n_;

    else

    {

        current_tabbing *f = new current_tabbing(v.n_);

        std::locale l = std::locale(s.getloc(), f);

        s.imbue(l);

    }   

}

Написать манипулятор с аргументами несколько сложнее. Для создания манипулятора, совместимого по интерфейсу со стандартными, нужно разобраться в стандартном механизме реализации. Вместо этого можно написать некоторый класс, в котором определить operator<<. Брюс Эккель вслед за Джерри Шварцем, одним из разработчиков объектно-ориентированной библиотеки ввода/вывода, называет такие классы эффекторами. Например, требуется выводить целые значения в двоичном виде. Назовем наш класс binary (листинг 8.13).
Листинг 8.13. «Манипулятор» для двоичного вывода

class binary
{ unsigned long k;
  public:
    binary( unsigned long k ): k( k ) {}
    friend ostream& operator<<( ostream& os, const binary& t );
};
inline ostream& operator<<( ostream& os, const binary& t )
{   const unsigned long MAX = numeric_limits<unsigned long>::max();     // 1
    unsigned long bit = ~( MAX >> 1 );                                  // 2
    while( bit ) { os << ( t.k & bit ? '1' : '0' ); bit >>= 1; }
    return os;
}

Такой класс позволяет выводить целые в двоичном виде, например:
short a = 2;
cout << binary( a ) << endl;
Этот класс всегда выводит количество бит, содержащееся в unsigned long, но можно легко преобразовать этот класс в шаблон, который позволит выводить нужное количество бит для беззнаковых целых (листинг 8.14).
Листинг 8.14. Эффектор-шаблон

// опережающие объявления
template <class T> class binary;
template<class T> ostream& operator<<( ostream& os, const binary<T>& t );
// класс-шаблон
template <class T>
class binary
{   T k;
  public:
    binary( T k ): k( k ) {}
    friend ostream& operator<< <>( ostream& os, const binary<T>& t );
};
template<class T>
inline
ostream& operator<<( ostream& os, const binary<T>& t )
{   T MAX = numeric_limits<T>::max();
    T bit = ~( MAX >> 1 );
    while( bit ) { os << ( t.k & bit? '1': '0' ); bit >>= 1; }
    return os;
}

Использовать этот класс-шаблон в качестве манипулятора можно так:
short a = -2;
cout << binary<unsigned short>( a ) << endl;
cout << binary<unsigned char>( 128 )<< endl;
На экран выведется
1111111111111110
10000000
Как видим, на экране ровно столько бит, сколько занимают типы unsigned short и unsigned char. Заметим, что использовать в качестве аргумента шаблона знаковый тип нельзя — программа зациклится!

> S>ident i;
> S>s << i << quoted("level 0") << endl
> S>  << i << quoted("level 0 again") << endl
> S>  << ++i << quoted("level 1") << endl
> S>  << --i << quoted("level 0") << endl;
> S>

 struct indent_t
 {
  struct incr
  {
   indent_t& src_;
   explicit incr(indent_t& src) : src_(src) {}
  };
  struct decr
  {
   indent_t& src_;
   explicit decr(indent_t& src) : src_(src) {}
  };
  int n_;
  explicit indent_t(int n = 1) : n_(n) {}
  incr operator++()
  { return incr(*this); }
  decr operator--()
  { return decr(*this); }
  indent_t operator+(int x) const
  { return indent_t(n_ + x); }
  indent_t operator-(int x) const
  { return indent_t(n_ - x); }
 };
 inline std::ostream& operator<<(std::ostream& os, indent_t const& v)
 {
  assert(v.n_ >= 0);
  for (int n = v.n_; n != 0; --n)
   os << "  ";
  return os;
 }
 inline std::ostream& operator<<(std::ostream& os, indent_t::incr v)
 {
  ++v.src_.n_;
  return os << v.src_;
 }
 inline std::ostream& operator<<(std::ostream& os, indent_t::decr v)
 {
  --v.src_.n_;
  return os << v.src_;
 }