strcpy vs strdup

Question

I read that strcpy is for copying a string, and strdup returns a pointer to a new string to duplicate the string.

Could you please explain what cases do you prefer to use strcpy and what cases do you prefer to use strdup?

Trilateral

Answer 1

strcpy(ptr2, ptr1) is equivalent to while(*ptr2++ = *ptr1++)

where as strdup is equivalent to

ptr2 = malloc(strlen(ptr1)+1);
strcpy(ptr2,ptr1);

(memcpy version might be more efficient)

So if you want the string which you have copied to be used in another function (as it is created in heap section) you can use strdup, else strcpy is enough.

Kerplunk

Good answer apart from the last sentence, which is confusing. I guess you mean the lifetime of the strdup()ed string can extend beyond the end of the current function, but that could be the case anyway (if the target of strcpy() is a caller-provided buffer, a global variable, or itself manually allocated using malloc() or new). – Ernaldus

Yes it is true that if the caller-provided buffer is a global variable or a dynamic pointer by itself then no need to use strdup I have just pointed one of the use case scenarios and thanks for completing it. – Kerplunk

Really love the while(*ptr2++ = *ptr1++)! :) – Oni

In the while loop, how does the exit condition work? – Delamare

@Delamare In C strings are ended by a nulbyte, which evaluates to false, and an assignment expression evaluates to the assigned value. – Unlade

@Oni If you do use an explict while(*ptr2++ = *ptr1++) in your program, don't forget to restore the pointers to their original values. After the while they'll be positioned at the null terminator. – Epiphytotic

Answer 2

The functions strcpy and strncpy are part of the C standard library and operate on existing memory. That is, you must provide the memory into which the functions copy the string data, and as a corollary, you must have your own means of finding out how much memory you need.

By constrast, strdup is a Posix function, and it performs dynamic memory allocation for you. It returns a pointer to newly allocated memory into which it has copied the string. But you are now responsible for this memory and must eventually free it.

That makes strdup one of the "hidden malloc" convenience functions, and that's presumably also why it is not part of the standard library. As long as you use the standard library, you know that you must call one free for every malloc/calloc. But functions such as strdup introduce a hidden malloc, and you must treat it the same as a malloc for the purpose of memory management. (Another such hidden allocation functions is GCC's abi::__cxa_demangle().) Beware!

Pangaro

Ahh, I always wondered why this wasn't in stdlib, and now I know. – Bik

Answer 3

strdup allocates memory for the new string on the heap, while using strcpy (or its safer strncpy varient) I can copy a string to a pre allocated memory on either the heap or the stack.

Company

Why the emphatic "either"? Is it not possible to use strcpy to copy into a static buffer? – Pangaro

I attempted to stress the difference in usage between the two functions without cluttering the answer with too many memory managment issues. but yes you are correct about static buffers. – Company

If you don't want clutter, you can just end the answer after "pre allocated memory" :-) – Pangaro

small nitpick: strncpy isn't safer than strcpy, as it does not guarantee that dest will be null terminated. Even worse, any unused space in the dest buffer will be filled with null terminators. This function was never intended for general usage. If you must use one of these functions, it's best to use strcpy and manually terminate dest. – Pernas

Answer 4

In the accepted answer, the implementation of strdup is presented as:

ptr2 = malloc(strlen(ptr1)+1);
strcpy(ptr2,ptr1);

However, that is somewhat sub-optimal because both strlen and strcpy need to find the length of the string by checking if each character is a \0.

Using memcpy should be more efficient:

char *strdup(const char *src) {
    size_t len = strlen(src) + 1;
    char *s = malloc(len);
    if (s == NULL)
        return NULL;
    return (char *)memcpy(s, src, len);
}

Caracal

Good answer that separates the conceptual use of strcpy to implement strdup from the practicality of doing so in an efficient way. – Whaler

Given that memcpy is dependent upon knowing string length, strlen is going to be called in either case. memcpy itself is equivalent to while ( len-- ) { *ptr2++ = *ptr1++ }, which each time does a subtraction, assignment, and test for zero, and then still has to run an assignment and then two post increments and their assignments anyways. So this memcpy technique seems less efficient. These seem like rather trivial distinctions and imaginary optimizations. – Duncandunce

Answer 5

char *strdup(char *pszSrch);

strdup will allocate storage the size of the original string. If storage allocation is successful, the original string is copied to the duplicate string.

strdupd return NULL on failure. If memory is not allocated, copy fails strdup return NULL.

Apocynaceous

Answer 6

for *memcpy another implementation is possible without incremental of dest and src :

while ( n-- ) { dest[n] = src[n] }

Letdown