I am calling strdup
and have to allocate space for the variable before calling strdup
.
char *variable;
variable = (char*) malloc(sizeof(char*));
variable = strdup(word);
Am I doing this right? Or is there something wrong here?
I am calling strdup
and have to allocate space for the variable before calling strdup
.
char *variable;
variable = (char*) malloc(sizeof(char*));
variable = strdup(word);
Am I doing this right? Or is there something wrong here?
If you're using the POSIX standard strdup()
, it calculates the space needed and allocates it and copies the source string into the newly allocated space. You don't need to do a malloc()
yourself; indeed, it immediately leaks if you do it since you overwrite the only pointer to the space you allocated with the pointer to the space that strdup()
allocated.
Hence:
char *variable = strdup(word);
if (variable == 0) …process out of memory error; do not continue…
…use variable…
free(variable);
If you do need to do the memory allocation, then you need to allocate strlen(word)+1
bytes in variable
and you can then copy word
into that newly allocated space.
char *variable = malloc(strlen(word)+1);
if (variable == 0) …process out of memory error; do not continue…
strcpy(variable, word);
…use variable…
free(variable);
Or calculate the length once and use memmove()
or perhaps memcpy()
:
size_t len = strlen(word) + 1;
char *variable = malloc(len);
if (variable == 0) …process out of memory error; do not continue…
memmove(variable, word, len);
…use variable…
free(variable);
Don't forget to ensure you know where the free()
is for every malloc()
.
you don't need to alloc space for use with strdup, strdup will do that for you. However you should free it after use.
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int main (){
const char* s1= "Hello World";
char* new = strdup (s1);
assert (new != NULL);
fprintf( stdout , "%s\n", new);
free (new);
return 0;
}
Edit: Be carefull with C++ as the variable name new is fine in C and not in C++ since it is a reserved name for operator new.
You seem confused. Forget what you know about pointers. Let's work with ints.
int x;
x = rand(); // Let us consider this the "old value" of x
x = getchar(); // Let us consider this the "new value" of x
Is there any way for us to retrieve the old value, or has it "leaked" from our view? As a hypothetical, suppose you were expected to let the OS know that you're finished with that random number, in order for the OS to perform some cleanup tasks.
Is the old value required for the generation of the new value? How can it be, when getchar
can't see x?
Let us now consider your code:
char *variable;
variable = (char*) malloc(sizeof(char*)); // Let us consider this the "old value" of variable
variable = strdup(word); // Let us consider this the "new value" of variable
Is there any way for us to retrieve the old value, or has it "leaked" from our view? You're expected to let the OS know when you're finished with malloc
ed memory, by calling free(variable);
.
Is the old value required for the generation of the new value? How can it be, when strdup
can't see variable?
FYI, here's an example of how strdup might be implemented:
char *strdup(const char *original) {
char *duplicate = malloc(strlen(original) + 1);
if (duplicate == NULL) { return NULL; }
strcpy(duplicate, original);
return duplicate;
}
As it currently stands you are always leaking 4 to 8 bytes (depending on your architecture). Regardless of strdup
which will allocate the required dynamic memory on its own you are reassigning the only variable that holds the pointer to your newly malloced memory area.
Simply say
char* const variable = strdup(word);