Rotation des bits de tout entier en C

Passez un entier 2 à cette fonction puis retournez un entier égal à 4

x = 2; x = rotateInt('L', x, 1); 

(décale les bits de 1 à gauche)

Exemple: 00000010 -> faire pivoter à gauche de 1 -> 00000100

mais si je réussis ceci:

 x = rotateInt('R', x, 3); 

il retournera 64, 01000000

Voici le code, quelqu’un peut-il corriger l’erreur … merci

 int rotateInt(char direction, unsigned int x, int y) { unsigned int mask = 0; int num = 0, result = 0; int i; for (i = 0; i > 1; } else if (direction == 'L') { if ((x & 128) == 1) x = (x ^ 129); else x = x << 1; } } result = (result ^ x); return result; } 

    Donc, je suppose que vous savez quels sont les changements de droite et de gauche. Et que vous sachiez la différence entre les changements arithmétiques et logiques.

    C n’a que des décalages arithmétiques. Il ne fait pas de décalage logique, il ne fait pas de rotation. d’accord j’ai menti, C fait des décalages logiques sur ints non signé.

    C’est exactement ce qui se passe avec une rotation: c’est la même chose qu’un décalage logique, sauf que lorsque vous dépassez la fin du numéro, les chiffres se “retournent” de l’autre côté. Par exemple

    0010 tourné à droite est 0001 . Si vous faites encore une rotation à droite, vous obtenez 1000 . Vous voyez, le 1 enveloppé ou tourné de l’autre côté de l’entier.

    La rotation à gauche est similaire: 0100 gauche 1000 gauche 0001 0010 etc.

    Notez que la rotation ne conserve pas le bit de signe comme le ferait un décalage arithmétique vers la droite.

    C n’a donc que des changements arithmétiques. Vous devez donc implémenter la “rotation” manuellement. Alors, faites une rotation à gauche. Vous voudriez:

    1. Capturez la valeur du bit le plus à gauche. (est-ce un 0 ou 1?)
    2. Faire un virage à gauche
    3. Définissez le bit le plus à droite, c’est-à-dire le bit dont nous avons parlé à l’étape 1 (qui doit être pivoté), sur la valeur correcte, en fonction de ce que nous avons capturé à l’étape 1.

    Vous devriez être capable de trouver une méthode similaire pour les rotations à droite.

    bonne chance!

    La réponse acceptée est très gentille et directe.

    Cependant, je faisais quelques exercices K & R pour rafraîchir mon C, et je voulais partager cette fonction de rotation qui peut être utile pour les personnes qui essaient d’apprendre des opérations de bout en bout.

     unsigned int rightRotateBits(unsigned int inputWord, int numberOfBitsToRotate) { int bitWidth = sizeof(inputWord) * 8; // Rotating 32 bits on a 32-bit integer is the same as rotating 0 bits; // 33 bits -> 1 bit; etc. numberOfBitsToRotate = numberOfBitsToRotate % bitWidth; unsigned int tempWord = inputWord; // Rotate input to the right inputWord = inputWord >> numberOfBitsToRotate; // Build mask for carried over bits tempWord = tempWord << (bitWidth - numberOfBitsToRotate); return inputWord | tempWord; } 

    Pour les rotations à gauche, il suffit de transmettre les valeurs comsockets entre -1 et -31 à l'argument bitAmount .

    Notez que cette fonction favorise la capacité d'apprentissage / la lisibilité / la simplicité par rapport à l'efficacité / la portabilité / la compacité.

    Regardez les opérateurs de décalage au niveau du bit:

    http://en.wikipedia.org/wiki/Bitwise_operators#Shifts_in_C.2C_C.2B.2B_and_Java

    Il semble que votre rotation à droite soit DROITE. 1 est tombé du côté et est revenu de la gauche?

    Quoi qu’il en soit, voici vos ingrédients:

    http://tigcc.ticalc.org/doc/keywords.html#if – pour déterminer si c’est ‘L’ ou ‘R’

    http://tigcc.ticalc.org/doc/keywords.html#for – pour compter le nombre de fois de décalage

    et

    http://msdn.microsoft.com/en-us/library/f96c63ed(VS.80).aspx – pour le déplacer réellement

    Allez, jouez avec. Cela fonctionnera éventuellement!

    Puisque personne ne vous a expliqué comment implémenter cela, vous pouvez utiliser les éléments insortingnsèques. Pour Visual Studio, ils sont _rotl, _rotl64, _rotr, _rotr64.

    Oh, mais la rotation et les quarts de travail sont deux choses différentes!

    Je recommande d’utiliser un unsigned int .

     #define DIR_LEFT 0 #define DIR_RIGHT 1 unsigned int rotateInt(unsigned int in, int amount, byte dir) { return(dir == DIR_RIGHT ? (in >> amount) | ((in & ((0x01 << amount) - 1)) << (sizeof(unsigned int)*8 - amount)) : (in << amount) | ((in & ~((sizeof(unsigned int)*8*8 - 1) >> amount))); }