将 uint8_t 数组转换为 C 中的结构体

Question

I'm beginner and I have a problem. I have this structure:

typedef struct {
  char data[26];
  int index;
  Placa_baza pb; // char nume_placa[10], int index_placa;
} PC;

And a structure vector:

static PC computers[5] = { ... };

I need to have a vector of type uint8_t pc[5*sizeof(computers)] instead of the structure vector. Is it well declared that way? :

uint8_t pc[5*sizeof(computers)]

How can I convert (cast) vector uint8_t pc[5*sizeof(computers)] to PC ?

To use the uint8_t pointer to address the structure, how should it be written?

Thank you in advance.

Answer 1

Your pc array, which could serve as a backup for the PC data is too large: it is sufficient to define it as:

uint8_t pc[sizeof(computers)];

Or possibly:

uint8_t pc[5 * sizeof(PC)];

You can then copy computers to pc with:

memcpy(pc, computers, sizeof pc);

You could also use a pointer to access the pc array as an array of PC :

PC *p = (PC *)pc;  // Don't do this!

Note however that this has undefined behavior as the byte array pc might not be properly aligned to access members of the PC structure, especially the index member and using such a pointer is a violation of the strict aliasing rule. It would be much better to define pc as PC pc[5]; and access this array via a uint8_t pointer of so required.

Answer 2

WARNING: Below program is just demonstration purpose, it may not behave same way with all compilers/systems. You can use it to test your compilers or systems behavior and modify accordingly.

In the below program am copying the contents from the structure computers to unit8_t .

as you can see its not easy and not portable, because we need to extract the data as per the boundaries of memory, allocated for variables.

#include <stdio.h>
#include <stdint.h>
#include <string.h>

typedef struct 
{
    char nume_placa[10];
    int index_placa;
}Placa_baza;

typedef struct {
    char data[26];
    int index;
    Placa_baza pb;
}PC;

int main()
{
    printf("sizeof(int) = %zu\n", sizeof(int));
    printf("sizeof(Placa_baza) = %zu\n", sizeof(Placa_baza));
    printf("sizeof(PC) = %zu\n", sizeof(PC));
    
    static PC computers[3] = { {"data1",1,"comp1", 0}, {"data2",2,"comp2", 1}, {"data3",3,"comp3", 2} };
    
    printf("sizeof(computers) = %zu\n\n", sizeof(computers));
    
    for(int i =0; i<3; i++)
        printf("data = %s, index =%d, pb.nume_placa =%s, pb.index_placa =%d\n",
            computers[i].data,
            computers[i].index,
            computers[i].pb.nume_placa, 
            computers[i].pb.index_placa
        );
        
    uint8_t uint8_t_pc[sizeof(computers)] = {0};
    
// for copying the contents from pc (uint8_t), used same variable names as that of structures

/*  typedef struct { */

    char data[26];
    int index;
    
/*      Placa_baza pb;
    } PC; */

/* typedef struct
{ */

    char nume_placa[10];
    int index_placa;
        
/*    }Placa_baza;
*/

    printf("\n sizeof(uint8_t_pc) = %zu\n", sizeof(uint8_t_pc));
    
    memcpy(uint8_t_pc,computers,sizeof(computers));
    
    int count = 0;
    uint8_t* temp = uint8_t_pc;
    
    printf("\n **From uint8_t memory ***\n");
    
    while(count < 3) {
    
        memcpy(data, temp, 26);
        // since there is a padding of 2 bytes , so extract from 28
        memcpy(&index, temp+28, 4);
        
        memcpy(nume_placa, temp+32, 10);
        //again there is a padding of 2 bytes
        memcpy(&index_placa, temp+44, 4);
        
        printf("data = %s, index = %d, nume_placa =%s , index_placa =%d\n", data, index, nume_placa, index_placa);
        temp = temp+sizeof(computers[0]);
        count++;
    }
    return 0;
}

Output:

sizeof(int) = 4                                                                                                                                  
sizeof(Placa_baza) = 16                                                                                                                          
sizeof(PC) = 48                                                                                                                                  
sizeof(computers) = 144                                                                                                                          
                                                                                                                                                 
data = data1, index =1, pb.nume_placa =comp1, pb.index_placa =0                                                                                  
data = data2, index =2, pb.nume_placa =comp2, pb.index_placa =1                                                                                  
data = data3, index =3, pb.nume_placa =comp3, pb.index_placa =2                                                                                  
                                                                                                                                                 
 sizeof(uint8_t_pc) = 144                                                                                                                        
                                                                                                                                                 
 **From uint8_t memory ***                                                                                                                       
data = data1, index = 1, nume_placa =comp1 , index_placa =0                                                                                      
data = data2, index = 2, nume_placa =comp2 , index_placa =1                                                                                      
data = data3, index = 3, nume_placa =comp3 , index_placa =2

online source

Update: Indeed we can use offsetof to get the offset of any member of the structure, so the statements inside while can also be replaced by below statments.

memcpy(data, temp+offsetof(PC, data), sizeof(computers[count].data));
memcpy(&index, temp+offsetof(PC, index), sizeof index);
memcpy(nume_placa, temp+offsetof(PC, pb.nume_placa), sizeof computers[count].pb.nume_placa);
memcpy(&index_placa, temp+offsetof(PC, pb.index_placa), sizeof index_placa);