ofstream ss;
 ...
 ss << number << endl;
 ...

F> ofstream ss;
F> ...
F> ss << number << endl;
F> ...
F>

Например, пусть нам требуется выводить целые значения в двоичном виде. Напишем класс binary (листинг 14.13).

Листинг 14.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();
  unsigned long bit = ~(MAX >> 1);                    // старший бит
  while(bit) { os << (t.k & bit?'1':'0'); bit >>= 1; }
  return os;
}

В функции operator<< самыми важными являются две строки:

const unsigned long MAX = numeric_limits<unsigned long>::max();
unsigned long bit = ~(MAX >> 1);                    // старший бит

В первой строке в переменную MAX заносится максимально возможное беззнаковое целое число, определенное в стандартном классе числовых пределов numeric_limits.
ПРИМЕЧАНИЕ
Класс-шаблон numeric_limits<> определен в заголовоке <limits>.
В двоичной записи это максимальное число представляет собой набор единичных битов:
1111...111
Во второй строке все биты числа сдвигаются вправо на один разряд; самый правый бит (младший разряд числа) теряется; в самый левый бит (старший разряд числа) заносится ноль, так как тип — беззнаковый. Таким образом, в результате сдвига образуется такая конфигурация битов:
0111...111
Потом эта конфигурация инвертируется операцией ~ и превращается в
1000...000
Это значение и заносится в переменную bit. Далее старшая единичка в цикле сдвигается на 1 разряд, пока значение bit не станет равно 0.
Такой класс позволяет нам выводить любые целые в двоичном виде, например:

short a = -2;
cout << binary(a) << endl;

Однако этот класс выводит в выходной поток всегда такое количество битом, которое содержится в типе unsigned long. Мы легко можем преобразовать этот класс в шаблон, который позволит выводить для беззнаковых целых нужное количество битов (листинг 14.14).

Листинг 14.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;
}

Обратите внимание на опережающие объявления и прототип функции-шаблона operator<< в классе binary.
Использовать данный класс-шаблон в качестве манипулятора можно так:

short a = -2;
cout << binary<unsigned short>(a) << endl;
cout << binary<unsigned char>(128)<< endl;

В результате на экран выводится следующее:
1111111111111110
10000000
Как видим, на экране ровно столько битов, сколько занимают типы unsigned short и unsigned char. Заметим, что использовать в качестве аргумента шаблона знаковый тип нельзя — программа зациклится!

void printbin(int x)
{
    __int64 y = x;
    int i = 32;
    while(i)
    {
        printf("%d", ((y  << (33-i))& 0x100000000I64) >> 32);
        i--;
    }
    printf("\n");
}

int _tmain(int argc, _TCHAR* argv[])
{
    printbin(100);
    return 0;
}

void printbin(int x)
{
    int i = 32;
    while(i)
    {
        printf("%d", (x & 0x80000000) >> 31);
        i--;
        x <<= 1;
    }
    printf("\n");
}

int _tmain(int argc, _TCHAR* argv[])
{
    printbin(100);
    return 0;
}