CODEWITHSUNDEEP
cmemory-management
Angus Comber
Angus Comber

Reputation: 9708

How to allocate memory for a struct with char* member

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.

Upvotes: 3

Views: 1783

Answers (2)

octopusgrabbus
octopusgrabbus

Reputation: 10685

Yes, you are correct about having to perform two memory allocation steps, the first for the struct and the second for the character string.

Unless this is an embedded system where memory space is at a premium, one way to get around this is to decide on a maximum string size. Yes, that does waste memory, if, for example, you only usually have 10 character or fewer strings and allocate for say 25 characters. 

#define WORKING_BUF_LEN 1024

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[WORKING_BUF_LEN={0};            /*  string */
     unsigned char* binval;   /*  any binary data */
   };

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

You could also do your own memory management to avoid fragmenting the heap if you plan on having many of these structs and hence many char* pointers, but that requires a lot of work. You'd overwrite new with a macro and assign pre-allocated storage to your pointer and then do storage allocation book keeping. Don't do it unless you have to.

Upvotes: 1

Macmade
Macmade

Reputation: 53950

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 );
}

Upvotes: 5

Related Questions