strdup() Function in C

Parameters

The strdup function takes a single parameter:

const char *str: This is a pointer to the null-terminated string that you want to duplicate. The string is not modified by the function.

It's important to note that str must be a null-terminated string. This means that the last character in the string must be a null character ('\0'). If str is not null-terminated, the behavior of strdup is undefined.

Let’s look at an example that shows what happens if you pass a non-null-terminated string to strdup:

#include <string.h>
#include <stdio.h>


int main() {
    char not_null_terminated[] = {'H', 'e', 'l', 'l', 'o'};
    char *duplicate = strdup(not_null_terminated);
    printf("Duplicate: %s\n", duplicate);
    free(duplicate);
    return 0;
}

You can also try this code with Online C Compiler

Run Code

In this case, the program has undefined behavior because not_null_terminated is not a null-terminated string. The strdup function will keep reading past the end of the string until it finds a null character in memory, which could lead to accessing invalid memory.

Return value

The strdup function returns a pointer to the newly allocated string, or NULL if memory allocation fails.

For example: 

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

int main() {
    char *original = "Hello, world!";
    char *duplicate = strdup(original);
    if (duplicate == NULL) {
        fprintf(stderr, "Memory allocation failed!\n");
        return 1;
    }
    printf("Duplicate: %s\n", duplicate);
    free(duplicate);
    return 0;
}

You can also try this code with Online C Compiler

Run Code

In this code, we check if duplicate is NULL after calling strdup. If it is, we print an error message & return from the function with a non-zero status to indicate that an error occurred. This is a good practice to avoid dereferencing a NULL pointer, which would cause undefined behavior.

Note: It's also important to remember to free the memory allocated by strdup when you're done with it, using the free function. If you forget to do this, you'll have a memory leak in your program.

Example

Let’s look at a complete example that shows the use of strdup:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main() {
    char *s1 = "Hello";
    char *s2 = strdup(s1);
    
    printf("s1 = %s\n", s1);
    printf("s2 = %s\n", s2);
    
    s1[0] = 'J';
    printf("s1 = %s\n", s1);
    printf("s2 = %s\n", s2);
    
    free(s2);
    return 0;
}

You can also try this code with Online C Compiler

Run Code

Output:

s1 = Hello
s2 = Hello
s1 = Jello
s2 = Hello

In this example:

1. We create a pointer s1 that points to the string literal "Hello".
 

2. We use strdup to create a duplicate of the string pointed to by s1. This new string is dynamically allocated & s2 points to it.
 

3. We print both s1 & s2 to confirm they contain the same string.
 

4. We modify the first character of s1 to 'J'. This changes the string literal, which is undefined behavior, but it's done here for demonstration purposes.
 

5. We print s1 & s2 again. s1 has changed, but s2 still contains the original string "Hello". This is because s2 points to a separate copy of the string.
 

6. We free the memory allocated by strdup to avoid a memory leak.

This example shows how strdup can be used to create a duplicate of a string that can be modified independently from the original.

Complexity analysis

The time complexity of strdup is O(n), where n is the length of the input string. This is because strdup needs to copy each character of the input string to the newly allocated string.

The space complexity is also O(n), because strdup allocates a new string of the same length as the input string.

Let’s understand in little more detail: 

1. Finding the length of the string: strdup first needs to find the length of the input string to know how much memory to allocate. It does this by iterating through the string until it finds the null terminator. This operation takes O(n) time, where n is the length of the string.
 

2. Memory allocation: strdup then allocates a new block of memory that is large enough to hold the string plus the null terminator. This operation takes O(1) time.
 

3. Copying the string: Finally, strdup copies the characters of the input string to the newly allocated string. This operation takes O(n) time, as each character needs to be copied.

So, the total time complexity is O(n) + O(1) + O(n), which simplifies to O(n).

Regarding space complexity, strdup allocates a new string of the same length as the input string. Therefore, the space complexity is O(n).

Note: It's important to keep these complexities in mind when working with large strings, as the time and space requirements can grow linearly with the size of the input.

Characteristics of strdup() in C

1. Dynamic memory allocation: strdup dynamically allocates memory for the new string using malloc. This means that the memory is allocated at runtime, and the size of the allocation is determined by the length of the input string.
 

2. Null-terminated strings: strdup works with null-terminated strings. It assumes that the input string is null-terminated and ensures that the output string is also null-terminated.
 

3. Returns a pointer: strdup returns a pointer to the newly allocated string. This pointer needs to be freed using the free function when it's no longer needed to avoid memory leaks.
 

4. Creates a deep copy: strdup creates a deep copy of the input string. This means that the new string is completely independent of the original string, and modifying one will not affect the other.
 

5. Requires <string.h>: The strdup function is declared in the <string.h> header file. You need to include this header file in your C program to use strdup.
 

6. Can fail: strdup can fail if there is not enough memory available to allocate the new string. In this case, it returns NULL. It's important to always check the return value of strdup before using the new string.
 

7. Part of POSIX, not C standard: strdup is part of the POSIX standard, but it's not part of the C standard. This means that it's available on POSIX-compliant systems (like Linux and macOS), but it may not be available on all C implementations.

Benefits of strdup() in C:

1. Simplicity: strdup provides a simple and concise way to duplicate a string. Without strdup, you would need to allocate memory for the new string manually, calculate the length of the original string, and then copy the characters one by one. strdup does all of this for you in a single function call.
 

2. Independence: strdup creates a completely independent copy of the string. This is useful when you want to modify the new string without affecting the original or when you want to pass a string to a function that might modify it.
 

3. Automatic memory allocation: strdup automatically allocates the correct amount of memory for the new string based on the length of the original string. This saves you from having to manually calculate the required memory size.
 

4. Null-termination: strdup ensures that the new string is properly null-terminated. This is important for string manipulation functions in C, which expect strings to be null-terminated.
 

5. Error handling: strdup returns NULL if it fails to allocate memory for the new string. This helps you check for and handle errors easily in your code.

Limits/Drawbacks of strdup() in C

1. Requires manual memory management: While strdup automatically allocates memory for the new string, it's the programmer's responsibility to free this memory when it's no longer needed using the free function. Forgetting to do this can lead to memory leaks.
 

2. Can fail: strdup can fail if there is not enough memory available to allocate the new string. This means you always need to check the return value of strdup for NULL before using the new string. Failing to do this can lead to segmentation faults if you try to use a NULL pointer.
 

3. Only works with null-terminated strings: strdup assumes that the input string is null-terminated. If you pass a non-null-terminated string to strdup, it will keep reading past the end of the string until it finds a null character, which can lead to undefined behavior.
 

4. Not part of the C standard: strdup is not part of the C standard library. It's part of the POSIX standard, which means it's available on POSIX-compliant systems like Linux and macOS, but it may not be available on all C implementations.
 

5. Can be inefficient for small strings: Because strdup dynamically allocates memory, it can be relatively inefficient for duplicating small strings. For very small strings, it might be more efficient to use a fixed-size array.
 

6. Does not handle embedded null characters: If the input string contains embedded null characters, strdup will only duplicate the part of the string up to the first null character.

Difference between strdup() and strndup() 

Frequently Asked Questions

What happens if I forget to free the memory allocated by strdup()?

If you forget to free the memory allocated by strdup() using the free() function, you will have a memory leak in your program. This means that the memory will remain allocated even after your program has finished using it, which can lead to your program consuming more and more memory over time. 

What happens if strdup() fails to allocate memory?

If strdup() fails to allocate memory (for example, if there is not enough memory available), it will return NULL. It's important to always check the return value of strdup() before using the duplicated string. If you try to use a NULL pointer, your program will likely crash with a segmentation fault.

Is strdup() thread-safe?

Yes, strdup() is thread-safe. Each call to strdup() returns a pointer to a newly allocated block of memory, so multiple threads can safely call strdup() simultaneously without interfering with each other. 

Conclusion

In this article, we have learned about the strdup() function in C, which is used to create a duplicate of a string. We explained its syntax, parameters, and return value and provided code examples. We've also analyzed its time and space complexity, discussed its key characteristics, benefits, and drawbacks, and compared it to a similar strndup() function. strdup() is a simple and useful function for string duplication in C, but it's important to use it correctly and always to remember to free the allocated memory when it's no longer needed to avoid memory leaks.

You can also check out our other blogs on Code360.