Allocating memory to a pointer giving as argument inside a function - c

Question

I want to write a function that can copy the content of a c-string to another c-string.
#include <stdio.h>
#include <string.h>
void copy(char*,char*);
int main(){
char* string = "hello";
char* destination;
copy(destination,string);
printf("Source: %s\nDestination: %s",string,destination);
system("pause");
return 0;
}
void copy(char* dest, char* src){
dest = malloc(strlen(src)*sizeof(char)); //Crashes
while (*src){
*dest++ = *src++;
}
}
Allocating the memory inside the function makes the program crash while allocating the memory before the function call works:
char* destination = malloc(strlen(string)*sizeof(char)); //works

Answer 1

The primary issue, that has been explained in several different ways, has to do with how you pass dest to copy(). When you pass a pointer to a function, e.g.:
void copy(char* dest, char* src) {
The function receives a copy of the pointer, which will point to the same address, but will have a different address of its own. So when you pass char *dest, the copy() function receives a copy of the dest pointer. When you then allocate dest in copy(), the caller main() has no idea what the address for dest is in copy() and no way of accessing the memory as returned by dest = malloc(strlen(src)*sizeof(char)); in copy().
Whenever you allocate memory in a function, if you are not returning the address for the newly allocated block of memory, you must pass the address of the pointer to the function (not a copy of the pointer). That way when you call malloc, you are assigning the return of malloc (the start address for the new block of memory) as the value of the pointer at the same address as in main().
If you remember nothing else, remember that rule: If you are allocating memory for a pointer you pass to the function, you must either (1) return the new address to the caller; or (2) pass the address of the pointer to the function for allocation.
Here is another example along similar lines with a few different approaches:
#include <stdio.h>
#include <stdlib.h>
void copy (char **dest, char *src);
int main (int argc, char **argv) {
char *str = argc > 1 ? argv[1] :
"A quick brown fox jumps over the lazy dog.";
char *dest = NULL;
copy (&dest, str);
printf ("\n str : %s\n dest : %s\n\n", str, dest);
free (dest); /* free allocated memory */
return 0;
}
void copy (char **dest, char *src)
{
if (!src) { /* validate src string */
fprintf (stderr, "%s() error: invalid string 'src'.\n",
__func__);
return;
}
size_t len = 0;
char *p = src;
for (;*p; p++, len++) {} /* strlen */
/* allocate and validate -- every time */
if (!(*dest = malloc (len * sizeof **dest + 1))) {
fprintf (stderr, "%s() error: virtual memory exhausted.\n",
__func__);
exit (EXIT_FAILURE);
}
p = *dest; /* copy src to dest */
for (; *src; src++) *p++ = *src;
*p = 0; /* null-terminate */
}
Output
$ ./bin/copystr
str : A quick brown fox jumps over the lazy dog.
dest : A quick brown fox jumps over the lazy dog.
Note: if you are not using gcc then change __func__ to the function name.

Answer 2

In your main() function you are declaring a variable destination of type char * without initializing it. You then pass destination as an argument to your copy() function. It's important to understand what data is being passed to copy(). In this case, since destination has not been initialized, we don't know what is being passed to copy(). This is fine when you malloc() before the function call because, in that scenario, destination has been initialized. In particular, its value is some address in the heap that was returned by malloc().
As others have noted, you should also be careful to allocate 1 byte more than the src string length in order to allow space for the null-terminator.

Answer 3

The problem is that copy takes to addresses - the current value of destination and the value of source.
Then it overwrites the current value of destination with the result of malloc.
The copy then occurs, and the malloced memory gets lost.
Either return the value of destination from copy, rather than pass it in.
or use char ** and *.
char * copy( char* src){
char * dest = malloc( (1+strlen(src))*sizeof(char)); //Crashes
char * toReturn = dest;
while (*src){
*dest++ = *src++;
}
return toReturn;
}
or
void copy( char ** dest, char* src){
/* overwrite pointer value with the result of malloc */
char * toCopy;
(*dest) = malloc((1+strlen(src))*sizeof(char)); //Crashes
toCopy = *dest;
while (*src){
*toCopy++ = *src++;
}
}