sostituire byte a 32 bit numero

Question

ho una funzione chiamata replaceByte(x,n,c) che sostituirà byte n in x con c con le seguenti limitazioni:

• Bytes numerate da 0 (LSB) a 3 (MSB)
• Esempi: replaceByte(0x12345678,1,0xab) = 0x1234ab78
• si può assumere 0 < = n = < 3 e 0 = c < < = 255
• ops legali : ! ~ &^| + << >>

• Max ops: 10

  int replaceByte(int x, int n, int c) { 
       int shift = (c << (8 * n)); 
       int mask = 0xff << shift; 
       return (mask & x) | shift; 
      } 
  

ma quando provo io ottenere questo errore:

ERRORE: test replaceByte (-2147483648 [0x80000000], 0 [0x0], 0 [0x0]) non riuscito ... ... Fornisce 0 [0x0]. Dovrebbe essere -2147483648 [0x80000000]

dopo aver realizzato che * non è un operatore legale ho finalmente capito ... e se siete curiosi, questo è quello che ho fatto:

int replaceByte(int x, int n, int c) { 
    int mask = 0xff << (n << 3); 
    int shift = (c << (n << 3)); 
    return (~mask & x) | shift; 
} 

Answer 1

Ahh ... Sei quasi arrivato.

basta cambiare

return (mask & x) | shift; 

a

return (~mask & x) | shift; 

Il mask dovrebbe contenere tutti quelli eccezione della zona da mascherare e non viceversa.

Sto usando questo semplice codice e funziona benissimo in gcc

#include<stdio.h> 

int replaceByte(int x, int n, int c) 
{ 
    int shift = (c << (8 * n)); 
    int mask = 0xff << shift; 
    return (~mask & x) | shift; 
} 

int main() 
{ 

    printf("%X",replaceByte(0x80000000,0,0)); 

    return 0; 
} 

Answer 2

Dal momento che questo sembra che i compiti a casa non ho intenzione di inviare codice, ma elencare i passi da eseguire:

1. Fusioni c in un numero a 32 bit in modo da non perdere alcun bit mentre spostando
2. Avanti, spostare c dal numero appropriato di bit a sinistra (se n==0 nessuno spostamento, se n==1 spostamento di 8 ecc.)
3. Creare una maschera di bit a 32 bit che azzererà gli 8 bit più bassi di x, quindi spostare questa maschera dello stesso valore di ultimo passo
4. Eseguire AND bit a bit della maschera di bit spostato e x per azzerare i bit appropriati di x
5. Eseguire OR bit a bit (o aggiunta) del c valore spostato e x per sostituire i bit mascherati di quest'ultimo