Swap d'octets 2 et 4 en un entier de 32 bits

J'ai eu cette question d'entrevue -

Swap d'octets 2 et octet 4 dans un entier de la séquence.
Integer est un 4 octet c'est à dire 32 bits

Mon approche a été d'utiliser char *pointer et un temp char pour échanger les octets.
Pour plus de clarté, j'ai cassé les étapes sinon, un tableau de caractères peut être considéré.

unsigned char *b2, *b4, tmpc;
int n = 0xABCD; ///expected output 0xADCB
b2 = &n;   b2++;  
b4 = &n;   b4 +=3;
///swap the values;
tmpc = *b2;
*b2 = *b4;
*b4 = tmpc;

Toutes les autres méthodes?

Je serais probablement utiliser logiques ET/OU/maj des trucs.
Avez-vous le travail?
Peut-être qu'ils n'aiment pas l'aliasing à travers incompatible types de pointeur.
0xABCD -> 0xADCB est un nybble échange, pas un octet de change, et le code donné ne sera pas l'appliquer.
vous ne pourrez pas obtenir le résultat souhaité avec ce code.

OriginalL'auteur czar x | 2013-07-01

  1. 7
    int someInt = 0x12345678;

int byte2 = someInt & 0x00FF0000;
int byte4 = someInt & 0x000000FF;
int newInt = (someInt & 0xFF00FF00) | (byte2 >> 16) | (byte4 << 16);

    Pour éviter des préoccupations au sujet de l'extension du signe:

    int someInt = 0x12345678;
int newInt = (someInt & 0xFF00FF00) | ((someInt >> 16) & 0x000000FF) | ((someInt << 16) & 0x00FF0000);

    (Ou, pour vraiment les impressionner, vous pouvez utiliser le triple XOR technique.)

    Juste pour le fun (probablement un tupo quelque part):

    int newInt = someInt ^ ((someInt >> 16) & 0x000000FF);
newInt = newInt ^ ((newInt << 16) & 0x00FF0000);
newInt = newInt ^ ((newInt >> 16) & 0x000000FF);

    (En fait, je viens de tester et cela fonctionne!)

    Vous avez à vous soucier de l'extension du signe si l'entrée est négative?
    c'est aussi bon
    qui dépend de la langue. Mes C est un peu rouillé.
    XOR technique c'est une très belle technique, mais d'échouer lorsque vous traitez avec des valeurs qui peuvent être égal à zéro. Un peu dangereuse 🙂
    Pas vrai. Si vous sentez que c'est vrai de nous montrer une référence crédible que les états qui.

    OriginalL'auteur Hot Licks

  2. 4

    Vous pouvez masquer les octets que vous voulez et de les déplacer autour. Quelque chose comme ceci:

    unsigned int swap(unsigned int n) {
  unsigned int b2 = (0x0000FF00 & n);
  unsigned int b4 = (0xFF000000 & n);
  n ^= b2 | b4;                 //Clear the second and fourth bytes
  n |= (b2 << 16) | (b4 >> 16); //Swap and write them.
  return n;
}

    Cela suppose que le "premier" de l'octet est la plus faible octet de poids fort (même si à la mémoire, elle peut être stockée big-endian).

    Aussi il utilise des entiers non signés partout pour éviter de droite décalage de l'introduction supplémentaire 1s en raison de l'extension du signe.

    Dépend si vous comptez partir du bas ou le haut. Ce n'est pas précisé dans l'énoncé du problème.
    ok c'est bon

    OriginalL'auteur Emil Sit

  3. 2

    Que sur les syndicats?

    int main(void)
{
    char  tmp;
    union {int n; char ary[4]; } un;

    un.n = 0xABCDEF00;
    tmp = un.ary[3];
    un.ary[3] = un.ary[1];
    un.ary[1] = tmp;
    printf("0x%.2X\n", un.n);
}

    dans > 0xABCDEF00

    hors>0xEFCDAB00

    S'il vous plaît n'oubliez pas de vérifier endianess. cela ne fonctionne que pour en little endian, mais ne devrait pas être difficile pour le rendre portable.

    OriginalL'auteur yeyo