'memdup' function in C?

Question

In C, you can use strdup to succinctly allocate a buffer and copy a string into it. As far as I'm aware, however, there is no similar function for general memory. For example, I can't say

struct myStruct *foo = malloc(sizeof(struct myStruct));
fill_myStruct(foo);

struct myStruct *bar = memdup(foo, sizeof(struct myStruct));
// bar is now a reference to a new, appropriately sized block of memory,
//   the contents of which are the same as the contents of foo

My question, then, is threefold:

1. Is there some standard library function like this that I don't know about?
2. If not, is there a succinct and preferably standard way to do this without explicit calls to malloc and memcpy?
3. Why does C include strdup but not memdup?

Answer 1

You can implement it whith a simple function:

void* memdup(const void* mem, size_t size) { 
   void* out = malloc(size);

   if(out != NULL)
       memcpy(out, mem, size);

   return out;
}

Answer 2

There is void *xmemdup (void const *p, size_t s) in GNU Gnulib's xalloc.h.

Note that it calls xalloc_die in case of insufficient memory.

Answer 3

You probably just want to define memdup() yourself and then simply use it in your code as already suggested. My version of the function follows.

void *memdup(const void *src, size_t n)
{
    void *dest;

    dest = malloc(n);
    if (dest == NULL)
            return NULL;

    return memcpy(dest, src, n);
}

As for the discussion whether memdup() is too trivial or even redundant, I don't think so. It is so useful for copying structures in your code. Both ANSI/ISO and POSIX standards for the C standard library contain so many convenience functions but unfortunately not this one.

Example: Reimplementation of strdup() using memdup().

char *strdup(const char *src)
{
    return memdup(src, strlen(src) + 1);
}

Example: Using memdup() to duplicate an object.

int some_function(const struct some_struct *some_const_data)
{
    struct some_struct *my_mutable_copy;

    my_mutable_copy = memdup(some_const_data, sizeof *some_const_data);
    if (my_mutable_copy == NULL)
        return -1;

    ...

    return 0;
}

Answer 4

Why does C include strdup but not memdup?

Prior to C23, strdup was not a C standard library function. It was a POSIX function though. And you can notice the pattern that prior to the dynamic memory TR, aside from the functions that exist to allocate memory, nothing returns you a pointer to a dynamically allocated memory buffer that you can call free on later (getdelim, getline, strdup, strndup - none of these were standard functions). I don't know the reasoning behind this design choice, but I guess memdup was also not implemented for the same reason.

Is there some standard library function like this that I don't know about?

No.

If not, is there a succinct and preferably standard way to do this without explicit calls to malloc and memcpy?

No.

Answer 5

The strdup function reads and copies up to the null on a null terminated string. However, normal data doesn't have any such delimiters, and therefore you need to give it the length of the data to copy.

Answer 6

Making a copy of an arbitrary memory structure isn't as straight forward as copying a string. How should you handle the case where the structure contains pointers to other structures (such as strings) for example? What does it mean to "duplicate" such a structure? There isn't one right answer to this, unlike the case for string. In that case, it's probably better to just let the application developer create a mechanism for making a copy of the structure according to their use cases rather than confuse the issue by pretending that there is a canonical way to handle it.