Question

My struct looks like this:

struct tlv_msg
{
   uint8_t datatype;   //type of data
   /* data stored in a union */
   union{
     int32_t s32val;          /*  int */
     int64_t s64val;          /*  long long */
     uint32_t u32val;         /*  unsigned int */
     uint64_t u64val;         /*  unsigned long long */
     char* strval;            /*  string */
     unsigned char* binval;   /*  any binary data */
   };

   uint32_t bytelen;  /* no. bytes of union/data part */
};

This struct uses a union to hold some different data types. I have an alloc function which allocates memory for the struct on the heap. Am I correct in thinking that if I am allocating for an integral type (ie the first four types above in union) I only need to allocate as follows:

tlv_msg* msg = malloc(sizeof(tlv_msg));

sizeof(tlv_msg) returns 24. I presume this is enough bytes to hold the largest data type in the union plus the other data members. (not sure why 24 – can someone explain?).

But if the data type to be stored is a pointer type, eg char* then I then need to also do this:

msg->strval = (char*)malloc(sizeof(string_length+1);

That would make sense to me and that seems to work but just wanted to check.

Answer 1

That’s perfectly right.

That said, you may want to create helper functions, to help you dealing with this.

For instance:

tlv_msg * new_tlv_msg( void );

/* There, you need to free struct members, if applicable */
void delete_tlv_msg( tlv_msg * msg ); 

/* Here you may copy your string, allocating memory for it */
tlv_msg_set_strval( tlv_msg * msg, char * str );

Implementation may be (basic, of course)

tlv_msg * new_tlv_msg( void )
{
    return calloc( sizeof( tlv_msg ), 1 ); 
}

void delete_tlv_msg( tlv_msg * msg )
{
    if( msg->strval != NULL )
    {
        free( msg-strval );
    }
    free( msg );
}

tlv_msg_set_strval( tlv_msg * msg, char * str )
{
    if( msg->strval != NULL )
    {
        free( msg-strval );
    }
    msg->strval = strdup( str );
}