Avviso: il cast aumenta l'allineamento richiesto

Question

Ultimamente sto lavorando a questa piattaforma per la quale un codebase legacy emette un gran numero di avvisi di "cast aumenta l'allineamento richiesto a N", dove N è la dimensione della destinazione del cast.

struct Message 
{ 
    int32_t id; 
    int32_t type; 
    int8_t data[16]; 
}; 

int32_t GetMessageInt(const Message& m) 
{ 
    return *reinterpret_cast<int32_t*>(&data[0]); 
} 

Speriamo che sia ovvio che un'implementazione "reale" sarebbe un po 'più complesso, ma il punto fondamentale è che ho i dati provenienti da qualche parte, ho sanno che è allineato (perché ho bisogno del id e type per essere allineati), eppure ottengo il messaggio che il cast sta aumentando l'allineamento, nel caso di esempio, a 4.

Ora so che posso sopprimere l'avviso con un argomento al compilatore, e so che posso gettare il bit tra parentesi per annullare * prima, ma non voglio veramente passare attraverso ogni bit di codice che necessita di questo tipo di manipolazione (c'è molto perché cariciamo un sacco di dati una parte del disco, e che i dati arrivano come char buffer in modo che possiamo facilmente puntare-anticipo), ma qualcuno può darmi qualche altra idea su questo problema? Voglio dire, per me sembra un'opzione così importante e comune che non vorresti avvertire, e se c'è effettivamente la possibilità di sbagliare, sopprimere l'avvertimento non aiuterà. Infine, il compilatore non può sapere come faccio a fare in modo che l'oggetto in questione sia effettivamente allineato nella struttura, quindi dovrebbe essere in grado di non preoccuparsi dell'allineamento su quell'oggetto particolare a meno che non sia stato colpito un byte o due?

Answer 1

Una possibile alternativa potrebbe essere:

int32_t GetMessageInt(const Message& m) 
{ 
    int32_t value; 
    memcpy(&value, &(data[0]), sizeof(int32_t)); 
    return value; 
} 

Per l'architettura x86, l'allineamento non sta andando alla materia più di tanto, è più un problema di prestazioni che non è davvero rilevante per il codice che avete fornito. Per altre architetture (es. MIPS) gli accessi disallineati causano eccezioni CPU.

---

OK, ecco un'altra alternativa:

struct Message 
{ 
    int32_t id; 
    int32_t type; 
    union 
    { 
     int8_t data[16]; 
     int32_t data_as_int32[16 * sizeof(int8_t)/sizeof(int32_t)]; 
     // Others as required 
    }; 
}; 

int32_t GetMessageInt(const Message& m) 
{ 
    return m.data_as_int32[0]; 
} 

---

Ecco variazione di quanto sopra che include i suggerimenti da cpstubing06:

template <size_t N> 
struct Message 
{ 
    int32_t id; 
    int32_t type; 
    union 
    { 
     int8_t data[N]; 
     int32_t data_as_int32[N * sizeof(int8_t)/sizeof(int32_t)]; 
     // Others as required 
    }; 
    static_assert((N * sizeof(int8_t) % sizeof(int32_t)) == 0, 
        "N is not a multiple of sizeof(int32_t)"); 
}; 

int32_t GetMessageInt(const Message<16>& m) 
{ 
    return m.data_as_int32[0]; 
} 


// Runtime size checks 
template <size_t N> 
void CheckSize() 
{ 
    assert(sizeof(Message<N>) == N * sizeof(int8_t) + 2 * sizeof(int32_t)); 
} 

void CheckSizes() 
{ 
    CheckSize<8>(); 
    CheckSize<16>(); 
    // Others as required 
}