Hatte daher gestern mal ein wenig rumprobiert.

1. Getestet, wann Zahl umkippt, d.h. negativ wird, dadurch habe ich die höchste Bitstelle gefunden (notwendig, da imo auf unterschiedlichen System ein Int unterschiedliche Dimensionen hat)
2. Die Zahl zerlegt und als bool feld[] gespeichert
3. Wieder zusammengesetzt, d.h. der Shift und dann aufaddieren.

-> Hat soweit auch geklappt, jedenfalls für positive Zahlen, aus einer -1 hat er komischerweise maxint gemacht

Daher bin ich wohl auf Eure Hilfe angewiesen, denn sonderlich schnell wird mein Code nicht sein, bei 3 for schleifen

dazu musst du die eigentlichen daten shiften und dann die selben nochmal geshiftet an die andere seite dran-OR-en.

#define ROT(val, n) ( ((val) << (n)) | ((val) >> (32 - (n))) )
wenn du auf 32 bit hantierst

( aus ergoogeltem http://cvs.gnome.org/viewcvs/evolution-exchange/xntlm/xntlm-md4.c?rev=1.2 )

Gibt es eine andere Möglichkeit die Größe eines Int zu ermitteln, als der von mir benutzte Ansatz?

int maxint)void)
{
  int zahl = 0;
  while (zahl >= 0)
  { 
    i++;
    zahl = (int)pow(2, i);
  }
  return (i + 1);
}

#include <limits.h>
sizeof(int) * CHAR_BIT

bist du des wahnsinns, pow() fuer ganzzahlen zu vergewaltigen??? fuer sowas nimmt man shifts.

#include <climits>
const int isize=CHAR_BITS*sizeof(int);

#include <limits>
const int isize=std::numeric_limits<int>::digits;

bist du des wahnsinns, pow() fuer ganzzahlen zu vergewaltigen??? fuer sowas nimmt man shifts.

Mhh jetzt, wo Du es sagst, fällt mir auch wieder ein, dass ein Linksshift das selbe bewirkt...

Danke Euch beiden jedenfalls

Noch 2 Tipps:
Das ROT Makro von c.rackwitz solltest du besser als inline Funktion implementieren. Und negative Werte zu shiften ist implementationsspezifisch. Deshalb bekommst du auch so "komische" Ergebnisse. Viele Compiler werden sowas wohl arithmetisch erledigen, aber auch das ist nicht sicher. Shifte deshalb nur unsigned Werte. Und hast du einen signed Wert als Ursprung, dann wandle den vorher zu unsigned und danach wieder zurück.