SYNOPSIS
        string set_bit(string str, int n)

BESCHREIBUNG
        Liefert einen neuen String, bei dem das Bit <n> in <str> gesetzt
        ist. Dabei wird der urspruengliche String <str> nicht veraendert.

        Jedes Zeichen enthaelt 6 Bits. In jedem Zeichen kann deshalb eine
        Zahl von 0 bis 63 gespeichert werde (2^6=64). Das erste Zeichen
        ist der Leerschlag " " mit dem Wert 0. Das erste Zeichen im String
        ist jenes mit den niedrigsten Bits (0-5).

        Der neue String wird automatisch verlaengert, falls noetig.

BEISPIELE
        string s;
        s=set_bit("?",5);

        Weil "?" einen Wert von 31 hat, ist das 6. Bit nicht gesetzt. Wird
        es gesetzt, so ergibt sich "_". Der String s enthaelt nun also "_".

        string s;
        s=set_bit("78",3);
        s=set_bit(s,8);

        s enthaelt nun "?<".

SIEHE AUCH
        clear_bit(E), last_bit(E), next_bit(E), test_bit(E), count_bits(E),
        and_bits(E), or_bits(E), xor_bits(E), invert_bits(E), copy_bits(E)
