Come si accede a un singolo byte di un intero?

Question

Per uno standard di comunicazione specificato RTCM SC104 3.1, ho bisogno di dividere i dati tra byte come una coppia di segmenti di dati a 12 bit. Quindi per un dato messaggio ho bisogno di inserire il numero del tipo di messaggio sul primo byte e metà del secondo byte. Quindi ho bisogno di iniziare un numero intero ID sul secondo byte e continuare con il terzo byte. Questo tipo di pattern continua fino alla fine del messaggio, tagliando altri numeri interi a 20 bit, 5 bit e altre dimensioni essenzialmente tagliando gli 0 che normalmente riempirebbero l'estremità MSB dei valori interi.

Non ho visto una definizione chiara ma presumo che debba uscire in ordine di byte di rete quindi prima di copiare bit dovrei invertire i miei numeri interi in memoria. Sono ancora abbastanza nuovo per cpp e mi sto chiedendo come ottengo i singoli byte che costituiscono un intero in memoria? Se riesco ad accedere ai byte, potrei usare bit per bit o dividere i bit da 2 byte su uno per il messaggio.

Ecco l'inizio della costruzione di un messaggio prima di aggiungere i dati:

//build message 1002 gps 00111110 1010 
    char buf1002[BUFFERSIZE]; 
    buf1002[0] = 0x3E; //00111110 
    buf1002[1] = 0xA0; //10100000 
//ref station id 12 bits of 16 
//ex unsigned short m = 1100; 
//m would be byte2 00000100 byte1 01001100 
//buf1002[1] would be 10100100 
//buf1002[2] would be 01001100 
//reverse bit order for network after building? 

La stazione di riferimento sarà da un breve, quindi un intero a 2 byte senza segno. Quindi come faccio a leggere un singolo byte da esso? Comincio con un puntatore di posizione di memoria? Se è così, allora?

Qualsiasi aiuto sarebbe molto apprezzato.

Answer 1

È possibile ricorrere a gioco di parole come byte, ad esempio:

const unsigned short s(1); 
const char* const bytes(reinterpret_cast<const char*>(&s)); 

const char NaturalOrder[sizeof(s)] = {bytes[0],bytes[1]}; 
const char EndianFlipped[sizeof(s)] = {bytes[1],bytes[0]}; 

(ma anche vedere il commento di dmckee quanto riguarda le dimensioni naturali di comandi incorporati, e considerare l'utilizzo di tipi larghezza fissa).

Answer 2

Se avete il vostro intero aspetto di 00001000 00000000 11000000 00110000 per esempio (sto facendo spazi a differenza di ogni singolo byte), contenute in esempio in un int a:

int  a; 
int  single_byte; 

a = the_number; 

Si potrebbe fare una funzione come

int  get_byte_in_integer(int byte_number, int integer); 

In modo che:

single_byte = get_byte_in_integer(1, a); // That would give you the 11000000 byte 

con

int get_byte_in_integer(int byte_number, int integer) 
{ 
     return (integer >> (byte_number << 3)) & 0xff); 
} 

Spero che questo aiuti, per la parte di byte.

Answer 3

Per controllare un po ', E con il bit che si desidera controllare:

bit = number & (1 << x); 

che metterà il valore del bit x in bit variabile.

Tratto da: How do you set, clear, and toggle a single bit?

Answer 4

È possibile utilizzare i campi di bit, come questo - alcuni avvertimenti alla fine:

typedef union packet { 
    struct { 
     unsigned int msgno : 12; // creates a 12 bit wide integral field 
     unsigned int msgtype : 12; 
     unsigned int somefield2 : 3; 
     unsigned int somefield3 : 5; 
    } fields; 

    unsigned char asbytes[4]; 
} packet; 

... 

packet p; 
// fill it, by using the field side of the union 
p.fields.msgno = 16; 
p.fields.msgtype = 12; 
p.fields.somefield2 = 6; 
// and retrieving them as regular bytes 
unsigned char abyte = p.asbytes[0]; 
abyte = p.asbytes[1]; 
// and so on 

Per me il vantaggio principale è la leggibilità: tutte le operazioni si comportano come le operazioni regolari anche se variabili di tipo integrale più stretto.Ci sono limitazioni (es. Portabilità) ma se non si devono indirizzare più architetture o compilatori o endian diversi può aiutare a rendere il programma molto più facile da leggere.