Question

I’m pretty new at C programming, and this type of thing keeps popping up. As a simple example, suppose I have a struct http_header with some char pointers:

struct http_header {
    char* name;
    char* value;
};

I want to fill an http_header where value is the string representation of an int. I “feel” like, semantically, I should be able to write a function that takes in an empty header pointer, a name string, and an int and fills out the header appropriately.

void fill_header(struct http_header *h, char* name, int value)
{
    h->name = name;
    char *value_str = malloc(100);
    sprintf(value_str, "%d", value);
    h->value = value_str;
}

int main(int argc, const char * argv[])
{
    struct http_header h;
    char *name = "Header Name";
    int val = 42;
    fill_header(&h, name, val);
    ...
    free(h.value);
}

Here, the calling code reads exactly as my intent, but in this case I’m creating the value string dynamically, which means I’d have to free it later. That doesn’t smell right to me; it seems like the caller then knows too much about the implementation of fill_header. And in actual implementations it may not be so easy to know what to free: consider filling an array of http_headers where only one of them needed to have its value malloced.

To get around this, I’d have to create the string beforehand:

void fill_header2(struct http_header *h, char* name, char *value_str)
{
    h->name = name;
    h->value = value_str;
}

int main(int argc, const char * argv[])
{
    struct http_header h;
    char *name = "Header Name";
    int value = 42;

    char value_str[100];
    sprintf(value_str, "%d", value);
    fill_header2(&h, name, value_str);
}

As this pattern continues down the chain of structures with pointers to other structures, I end up doing so much work in top level functions the lower level ones seem hardly worth it. Furthermore, I’ve essentially sacrificed the “fill a header with an int” idea which I set out to write in the first place. I’m I missing something here? Is there some pattern or design choice that will make my life easier and keep my function calls expressing my intent?

P.S. Thanks to all at Stackoverfow for being the best professor I’ve ever had.

Answer 1

Well, I would go with the first approach (with a twist), and also provide a destroy function:

struct http_header *make_header(char *name, int value)
{
    struct http_header *h = malloc(sizeof *h);
    /* ... */
    return h;
}

void destroy_header(struct http_header *h)
{
    free(h->name);
    free(h);
}

This way the caller doesn’t have to know anything about http_header.

You might also get away with a version that leaves the main allocation (the struct itself) to the caller and does it’s own internal allocation. Then you would have to provide a clear_header which only frees that fill allocated. But this clear_header leaves you with a partially-valid object.