recupera un byte de un entero de 32 bits utilizando operadores bitwise

Aquí está el problema y lo que tengo actualmente, simplemente no entiendo cómo está mal …

getByte – Extrae el byte n de la palabra x Bytes numerados de 0 (LSB) a 3 (MSB) Ejemplos: getByte (0x12345678,1) = 0x56 Operaciones legales:! ~ & ^ | + <> Max ops: 6 Rating: 2

int getByte(int x, int n) { return ((x <> (8 * n)); } 

Su cambio no tiene ningún sentido: primero, se desplaza hacia la izquierda en (24 – 8n) bits, luego se desplaza hacia la derecha en 8n bits. ¿Por qué? Además, está mal. Si n es 0, desplaza x la izquierda en 24 bits y devuelve ese valor. Trate de lápiz y papel para ver que esto es totalmente incorrecto.

El enfoque correcto sería hacer:

 int getByte(int x, int n) { return (x >> 8*n) & 0xFF; } 

A menos que esté totalmente equivocado, su código es matemáticamente incorrecto.

 getByte(0x000000ff, 0) { 24 - 8 * n = 24; 8 * n = 0; 0x000000ff << 24 = 0xff000000; 0xff000000 >> 0 = 0xff000000; return 0xff000000; // should return 0xff } 

No se les permite usar operadores - y especialmente * es un problema (no se puede hacer * 8 ). Se me ocurrió esto:

 uint8_t getByte (uint32_t x, int n) { switch (n) { case 0: return x & 0xff; case 1: return (x >> 8) & 0xff; case 2: return (x >> 16) & 0xff; case 3: return x >> 24; } } 

No exactamente hermoso, pero se ajusta a la descripción del problema: 6 operadores, todos ellos legales.

EDIT: acaba de tener una idea (bastante obvia) de cómo evitar * 8

 uint8_t getByte (uint32_t x, int n) { return (x >> (n << 3)) & 0xff; } 

No entiendo cómo funciona tu función. Intenta esto en su lugar:

 int getByte(int x, int n) { return (x >> (8 * n)) & 0xFF; }