Не понимаю манипуляторы. Как они работают?

#include <cstdlib>
#include <iostream>
 
using namespace std;
 
ostream& tab (ostream& output)          //Manipulator
{
    return output << "\t";
}
 
int main(int argc, char *argv[])
{
    cout << tab;
    cout << "Hello";       //How (?!?!) does it converts to: tab(cout), if it really does?
    //...................
    cout << endl;
    //...................
    tab(cout);             //I understand
    cout << "Hello ";
    system("PAUSE > NULL");
    return EXIT_SUCCESS;
}

 cout.operator <<( tab );

operator<<(cout,tab);

class basic_ostream
{
   public:
   //blablabla
   void operator<< ((ostream&) * (ostream&));
   void operator<< ((const ostream &) *(ostream&))
}

wcout << tab; //

ostream& tab ( ostream& output, int t = 10 ) { ... }
....
cout << tab;

      __ostream_type&
      operator<<(__ostream_type& (*__pf)(__ostream_type&))
      {
    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // DR 60. What is a formatted input function?
    // The inserters for manipulators are *not* formatted output functions.
    return __pf(*this);
      }

cout << setw(6) << 289;

#include <iostream>
 
class tab
{
public:
    tab(size_t count):
    m_count(count)
    {
    }
 
    friend std::ostream& operator<<(std::ostream& stream, const tab& tab_manip)
    {
        for (size_t i = 0; i < tab_manip.m_count; ++i)
            stream << '\t';
 
        return stream;
    }
 
private:
    size_t m_count;
};
 
int main()
{
    std::cout << tab(3) << "Hello" << std::endl;
 
    return 0;
}

#include <iostream>
 
class tab
{
public:
    tab(size_t count):
    m_count(count)
    {
    }
 
    friend /*std::ostream&*/ void operator<<(std::ostream& stream, const tab& tab_manip)
    {
        for (size_t i = 0; i < tab_manip.m_count; ++i)
            stream << '\t';
 
        //return stream;
    }
 
private:
    size_t m_count;
};
 
int main()
{
    //std::cout << tab(3) << "Hello" << std::endl;
 
    std::cout << tab(3);
    std::cout << "Hello" << std::endl;
 
    return 0;
}

#include <iomanip>
//...
cout << setprecision(3) << 3.234;

myClass multyplyByTen;
cout << multiplyByTen << 3;  //Ну типа умножили на десять и вывели

  struct _Setprecision { int _M_n; };
 
  /**
   *  @brief  Manipulator for @c precision.
   *  @param  n  The new precision.
   *
   *  Sent to a stream object, this manipulator calls @c precision(n) for
   *  that object.
  */
  inline _Setprecision 
  setprecision(int __n)
  { return { __n }; }
 
  template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>& 
    operator>>(basic_istream<_CharT, _Traits>& __is, _Setprecision __f)
    { 
      __is.precision(__f._M_n); 
      return __is; 
    }
 
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>& 
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setprecision __f)
    { 
      __os.precision(__f._M_n); 
      return __os; 
    }

#include <iostream>
 
class MultiplyByTenManip
{
public:
    MultiplyByTenManip(std::ostream *stream = 0):
    m_stream(stream)
    {
    }
 
    template<typename T>
    std::ostream& operator <<(const T& value)
    {
        return *m_stream << value * 10;
    }
 
    friend MultiplyByTenManip operator <<(std::ostream& stream, const MultiplyByTenManip& manip);
 
private:
    std::ostream *m_stream;
};
 
MultiplyByTenManip operator <<(std::ostream& stream, const MultiplyByTenManip&)
{
    return MultiplyByTenManip(&stream);
}
 
MultiplyByTenManip multiply_by_ten;
 
int main()
{
    std::cout << multiply_by_ten << 42 << std::endl;
 
    return 0;
}

cout<<crypto_in("346767")<<" Hellow friend,how are you?"<<stop_crypt<<" Hellow friend, how are you?";

#include <iostream>
 
class MultiplyByTenManipException : std::exception
{
public:
    virtual ~MultiplyByTenManipException() throw()
    {
    }
 
    virtual const char *what() const throw()
    {
        return "impossible output the value bypassing stream";
    }
};
 
class MultiplyByTenEndManip
{
};
 
class MultiplyByTenBeginManip
{
public:
    MultiplyByTenBeginManip(std::ostream *stream = 0):
    m_stream(stream)
    {
    }
    
    template<typename T>
    MultiplyByTenBeginManip operator <<(T value)
    {
        if (m_stream == 0)
            throw MultiplyByTenManipException();
 
        *m_stream << value * 10;
 
        return *this;
    }
 
    MultiplyByTenBeginManip operator <<(const char *str)
    {
        *m_stream << str;
 
        return *this;
    }
 
    std::ostream& operator <<(const MultiplyByTenEndManip&)
    {
        return *m_stream;
    }
 
    friend MultiplyByTenBeginManip operator <<(std::ostream& stream, const MultiplyByTenBeginManip& manip)
    {
        return MultiplyByTenBeginManip(&stream);
    }
 
private:
    std::ostream *m_stream;
};
 
MultiplyByTenBeginManip multiply_by_ten_begin;
MultiplyByTenEndManip multiply_by_ten_end;
 
int main()
{
    std::cout << multiply_by_ten_begin << 42 << "  " << 3.7 << multiply_by_ten_end << std::endl;
 
    return 0;
}

#include <iostream>
 
class TransformManipulatorException : std::exception
{
public:
    virtual ~TransformManipulatorException() throw()
    {
    }
 
    virtual const char *what() const throw()
    {
        return "impossible output the value bypassing stream";
    }
};
 
class TransformManipulatorEnd
{
};
 
template<typename Function>
class TransformManipulatorBegin;
 
template<typename Function>
TransformManipulatorBegin<Function> operator <<(std::ostream& stream,
    const TransformManipulatorBegin<Function>& manip);
 
template<typename Function>
class TransformManipulatorBegin
{
public:
    TransformManipulatorBegin(Function *func, std::ostream *stream = 0):
    m_func(func),
    m_stream(stream)
    {
    }
    
    template<typename T>
    TransformManipulatorBegin operator <<(T value)
    {
        if (m_stream == 0)
            throw TransformManipulatorException();
 
        *m_stream << m_func(value);
 
        return *this;
    }
    
    TransformManipulatorBegin<Function> operator <<(const char *str)
    {
        if (m_stream == 0)
            throw TransformManipulatorException();
 
        *m_stream << str;
 
        return *this;
    }
    
    std::ostream& operator <<(const TransformManipulatorEnd&)
    {
        return *m_stream;
    }
 
    friend TransformManipulatorBegin<Function> operator << <Function>(std::ostream& stream,
        const TransformManipulatorBegin<Function>& manip);
 
private:
    Function *m_func;
    std::ostream *m_stream;
};
 
template<typename Function>
TransformManipulatorBegin<Function> operator <<(std::ostream& stream,
    const TransformManipulatorBegin<Function>& manip)
{
    return TransformManipulatorBegin<Function>(manip.m_func, &stream);
}
 
int func(int val)
{
    return val * 10;
}
 
double func2(double val)
{
    return val / 2.0;
}
 
int main()
{
    std::cout << TransformManipulatorBegin<int(int)>(func)
                 << 10 << "  " << 42
                 << TransformManipulatorEnd()
              << std::endl;
    
    std::cout << TransformManipulatorBegin<double(double)>(func2)
                 << 10.8 << "  " << 42.22
                 << TransformManipulatorEnd()
              << std::endl;
 
    return 0;
}