Thread: A string from a different function

Code:

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

void changeString(char *str);
int main(){
     char *string;
     string = (char *)malloc(5 * sizeof(char));
     changeString(string);
     printf("\nNew string is %s\n",string);
     free(string);
     return 1;
}
void changeString(char *str){
      char *name;
      int ptr=0;

      name = (char *)malloc(sizeof(char)*5);
      do{
         scanf("%c", &name[ptr]);
         ptr++;
         if(ptr == 5){
              name = (char *)realloc(name, 10 * sizeof(char));
         }
         
      }while(name[ptr-1] != '\n');
      str = (char *)realloc(str, sizeof(char) * ptr);
      strcpy(str,name);
      free(name);
}

What's the output of printf?
When i run the program it works properly, but with valgrind it doesnt.

When you pass a value as an argument to a C function, it is passed "by value". That is, a byte-for-byte copy of the value of the argument is placed on the call stack or in a register, where the function is free to do whatever it wants, including modifying that value.

However, any changes to the value are not copied back to the caller. There is no provision in C for any kind of "update" to a value to propagate from a called function back to its caller.

This is why we use pointers. With a pointer, you can call "by reference." The calling function puts the address of a modifiable object onto the stack (or in a register) as an argument to the function. The callee (the function) takes the address, uses the address to modify the value stored, and then returns. After which, the calling function can see the updates that have been made.

In your code, you attempt to use the realloc() function to change the size of the memory block pointed to by the parameter str. The realloc() function is documented as having three possible behaviors:

1. It changes the size of the referenced memory block, leaving the pointer unchanged but increasing the space available.
2. It allocates a new memory block of sufficient size, copies the contents, and returns a differently-valued pointer to the new memory block.
3. It fails to allocate and returns null.

Your code does not allow for case 2 or case 3. You call realloc, and assign the resulting value to str. But str is a parameter, and parameters don't get copied back to the caller, so any change to str will be lost. The only time your code can work is case 1.

Note: This explains why your code doesn't work with valgrind. Most memory allocators will return blocks aligned to either 8 or 16 bytes. Meaning that they almost certainly allocate in chunks at least that big. If your system's malloc is 16-byte aligned, that probably explains why you can get a realloc from 5 to 10 bytes with no problem. Using valgrind turns on some safety checks, which likely makes realloc always return a new block.

In order to get your code to work for case 3, you simply have to check for null and then print a message and die.

In order to get your code to work for case 2, you need to either (a) pass the string parameter by reference (using a pointer) instead of by value; or (b) return the new value from your function, and update the string in main.