c := 0
while b != 0
    if (b and 1) != 0
        c := c + a
    shift a left by one
    shift b right by one

return c

Hier wird Über Addition und Bitshift Multiplikation mit beliebigen Zahlen realisiert. Allerdings ist dabei ja immernoch die "normale" Addition erforderlich.
Kann man Addition und Subtraktion auch ausschließlich über die Bitwise Operatoren realisieren? (Division ist nicht so wichtig)

const size_t FELDLAENGE = 255u; //zB

class bit
{
   private:
    std::bitset<FELDLAENGE> a;

   public:
    bit& operator+=(const bit& b)
    {
        std::bitset<FELDLAENGE> sum   = a ^ b.a;
        std::bitset<FELDLAENGE> carry = a & b.a;

        while (carry.any())  // != 0
        {
            carry <<= 1u;
            a = sum;
            sum = a ^ carry;
            carry = a & carry;
        }

        a=sum;
        return *this;
    }

    bit& operator*=(const bit& b)
    {
        std::bitset<FELDLAENGE> one = 1u; //geht das eleganter?

        bit copy, p;
        copy.a = b.a;

        for(; a!=0; a>>=1u, copy.a<<=1u)
            if((a&one).any())
                p+=copy;
        a=p.a;

        return *this;
    }
};

Das funktioniert auch ziemlich gut. Hat jemand eine Idee zum Algorithmus für die Subtraktion? Gibt es Verbesserungen an den beiden Algorithmen? Oder am Klassendesign ? Außerdem gefällt mir der Umweg über das bitset "one" nicht (Zeile 28).Gibt es Alternativen?

Schonmal Danke für alle Anregungen

BTW: Die Performance ist zweitrangig. Es sollte sich möglichst so wie die PODs verhalten, die drei Grundrechenarten unterstützen und möglichst portabel sein

Hat jemand eine Idee zum Algorithmus für die Subtraktion?

Das Zweierkomplement vom Subtrahent bilden und dann einfach draufaddieren.

Außerdem gefällt mir der Umweg über das bitset "one" nicht (Zeile 28).Gibt es Alternativen?

a.test(1)

Trotzdem habe ich noch einige Fragen zu den bitsets

Sind Bitsets unabhängig von der Endianness? Ich vermute mal ja. Also greift zB [0] immer auf das ganz "rechte" Bit zu oder auf das am wenigst wertige Bit zu?

Wie initialisiere ich am besten ein bitset mit eins?

//Variante 1: Standardkonstruktor und Indexoperator
bitset<50> eins; eins[0]=1;

//Variante 2: Zuweisen eines POD's.
bitset<50> zwei = 1; //Was ist, wenn die POD variable weniger bits hat als das Bitset?

//Variante 3: Initialisierung über string
bitset<50> drei = string("1"); //wieder unabhängig von Endianness? Und weniger "Zeichen" als Bits. Problemlos?