将uint8_t数组复制到结构

Question

I have this array

uint8_t *buffer = "JOHN:DOE:010119:M:FOO:BAR";

and I want to copy it field by field to data structure

typedef struct{
  uint8_t firstName[5];
  uint8_t pad1;
  uint8_t lastName[4];
  uint8_t pad2;
  uint8_t dateOfBirth[7];
  uint8_t pad3;
  uint8_t genre;
  uint8_t pad4;
  uint8_t car[4];
  uint8_t pad5;
  uint8_t phone[4];
  uint8_t pad6;
}DataStructTypeDef;

Let's say that all lengths are fixed (eg. firstName is always composed of 4 characters, lastName of 3 etc ...)

I used this approach:

DataStructTypeDef foo;
memcpy((void *)&foo, (void *)buffer, sizeof(DataStructTypeDef));

When I try to print dateOfBirth it shows the whole array starting from 01012019 like this

int main(void)
{
  DataStructTypeDef foo;
  memcpy((void *)&foo, (void *)buffer, sizeof(DataStructTypeDef));
  printf("%s", foo.dateOfBirth); // It prints 010119:M:FOO:BAR
//printf("%s", foo.dateOfBirth); // Expected value 010119
  return 0;
}

Answer 1

Since the char array members you are copying are not null terminated, printf("%s", will not know when it has encountered the end of each string.

This can be controlled in printf by limiting the amount of characters that print...

For example:

printf("%.*s", (int)sizeof(foo.dateOfBirth), foo.dateOfBirth);

An equivalent would be:

printf("%.6s", food.dateOfBirth);

.* specifies the "precision" of characters you want to print. So in your case, dateOfBirth = precision/size 6.

Answer 2

With the fixed struct of

typedef struct {
    uint8_t firstName[4];
    uint8_t pad1;
    uint8_t lastName[3];
    uint8_t pad2;
    uint8_t dateOfBirth[6];
    uint8_t pad3;
    uint8_t genre;
    uint8_t pad4;
    uint8_t car[3];
    uint8_t pad5;
    uint8_t phone[3];
    uint8_t pad6;
}DataStructTypeDef;

This works for me:

int main(void)
{
    uint8_t *buffer = "JOHN" "\0" "DOE" "\0" "010119" "\0" "M" "\0" "FOO" "\0" "BAR";
    DataStructTypeDef foo;
    memcpy((void *)&foo, (void *)buffer, sizeof(DataStructTypeDef));
    printf("%s", foo.dateOfBirth); // Expected value 01012019
}

The buffer looks horribly mangled because if I put "\\0" "010119" as "\\0010119" , it's interpreting the escape the wrong way. A better solution would probably be to keep it as one and fully write out the octal sequence as \\000 :

uint8_t *buffer = "JOHN\000DOE\000010119\000M\000FOO\000BAR";

Here, each \\000 becomes a null byte and it doesn't clash with the 010119 following one of the escape sequences.

Alternatively, it works if I take the original buffer string of "JOHN:DOE:010119:M:FOO:BAR" and just replace all the : after copying, like this:

foo.pad1 = foo.pad2 = foo.pad3 = foo.pad4 = foo.pad5 = foo.pad6 = '\0';

Answer 3

1. Modify your structure

Add an extra byte to each field to accommodate the '\\0' character. For eg use

uint8_t firstName[5];

instead of

uint8_t firstName[4];

2. Parse the fields individually and end each field with '\\0'

Instead of copying the entire buffer in one go, copy the elements one by one. Since, the size of each field is fixed, the offset from the start of the buffer is fixed and this makes the job of parsing easier.

Answer 4

After memcpy add this: foo.pad1 = foo.pad2 = foo.pad3 = foo.pad4 = foo.pad5 = 0; . But I hope this is exercise, not a real structure for real job.