Échanger deux bits avec une seule opération en C?

Essayer:

x ^= 0x14;

Qui fait basculer les deux bits. C'est un peu de clarté dans la question que vous première mention de swap et de donner ensuite une bascule exemple. De toute façon, pour échanger les bits:

x = precomputed_lookup [x];

où precomputed_lookup est une 256 tableau d'octets, pourrait être le moyen le plus rapide, il dépend de la vitesse de la mémoire par rapport à la vitesse du processeur. Sinon, c'est:

x = (x & ~0x14) | ((x & 0x10) >> 2) | ((x & 0x04) << 2);

EDIT: plus d'informations sur le basculement de bits.

Lorsque vous xor (^) de deux valeurs entières ensemble, le xor est effectuée au niveau du bit, comme ceci:

for each (bit in value 1 and value 2)
   result bit = value 1 bit xor value 2 bit

de sorte que le bit 0 de la première valeur est xor ed avec le bit 0 de la deuxième valeur, bit 1 avec le bit 1 et ainsi de suite. L'opération xor de ne pas modifier les autres bits de la valeur. En effet, c'est un parallèle bits xor sur plusieurs bits.

En regardant la table de vérité pour le xor, vous verrez qu'utilise xor un peu avec la valeur "1", effectivement bascule de l'bits.

 a  b a^b
 0  0  0
 0  1  1
 1  0  1
 1  1  0

Donc, pour basculer entre les bits 1 et 3, écrire un nombre binaire avec un où vous souhaitez que le bit à bascule et un zéro si vous voulez laisser la valeur inchangée:

00001010

convertir à l'hex: 0x0a. Vous pouvez passer autant de bits que vous le souhaitez:

0x39 = 00111001

basculer les bits 0, 3, 4 et 5

La méthode suivante n'est PAS un seul C l'enseignement, c'est juste un peu tripoter la méthode. La méthode a été simplifié à partir de Permutation des bits individuels avec XOR.

Comme indiqué dans Roddy réponseune table de recherche serait le mieux. Je ne suggèrent ce au cas où vous ne souhaitez pas utiliser un. Ce sera en effet swap de bits également, et pas seulement de la bascule (qui est, tout ce qui est dans le bit 2 à 4, et vice-versa).

• b: l'original de votre valeur ???1?0?? par exemple
• x: juste un temp

• r: le résultat

  x = ((b >> 2) ^ (b >> 4)) & 0x01
  
  r = b ^ ((x << 2) | (x << 4))

Explication rapide: obtenir les deux bits que vous souhaitez regarder et XOR, stocker la valeur de x. En reportant cette valeur de retour de bits 2 et 4 (et OU pratiquent ensemble), vous obtenez un masque que lorsque XORed de retour avec b permettra d'échanger vos deux d'origine bits. Le tableau ci-dessous montre tous les cas possibles.

bit2: 0 1 0 1  
bit4: 0 0 1 1  
x   : 0 1 1 0   <-- Low bit of x only in this case 
r2  : 0 0 1 1  
r4  : 0 1 0 1

Je n'ai pas tester pleinement le présent, mais pour les quelques cas que j'ai essayé rapidement, il semblait fonctionner.

La fonction ci-dessous échange les bits 2 et 4. Vous pouvez l'utiliser pour précalculer une table de recherche, si nécessaire (de sorte que la permutation devient une seule opération):

unsigned char swap24(unsigned char bytein) {
    unsigned char mask2 = ( bytein & 0x04 ) << 2;
    unsigned char mask4 = ( bytein & 0x10 ) >> 2;
    unsigned char mask  = mask2 | mask4 ;
    return ( bytein & 0xeb ) | mask;
}

J'ai écrit chaque opération sur une ligne distincte pour la rendre plus claire.

#include<stdio.h>

void printb(char x) {
    int i;
    for(i =7;i>=0;i--) 
        printf("%d",(1 & (x >> i)));
    printf("\n");
}

int swapb(char c, int p, int q) {
    if( !((c & (1 << p)) >> p) ^ ((c & (1 << q)) >> q) )
        printf("bits are not same will not be swaped\n");
    else {
        c = c ^ (1 << p);
        c = c ^ (1 << q);
    }
    return c;
}

int main() 
{
    char c = 10;
    printb(c);
    c = swapb(c, 3, 1);
    printb(c);
    return 0;
}