trying to understand C string pointers

[adrivetest]

Hi, I'm new with pointers actually. And im struggling to understand a function im trying to write....what im trying to understand is when a caller passes in a string pointer to a function that tries to clear up the pointer, why doesn't it get cleared up when we return to the caller? Here is an example :

#include<stdio.h> 
#include<stdlib.h>
#include<string.h>
 
void cfun(void);
void cfun2(char *name2);
int main ()
{
    cfun();
 
    return 0;
}
 
void cfun(void)
{
char *name;
name = (char *)malloc(20*sizeof(char));
 
    name = "wwoohoho";
 
    cfun2(name);
 
    printf("back to cfun's name at the end ..%s\n",name);
 
 
}
 
void cfun2(char *name2)
{
    printf("in...%s\n",name2);
 
    free(name2);
    name2 = NULL;
 
    printf("cfun2 after freeing name...%s\n",name2);
}
 

result :

in...wwoohoho
cfun2 after freeing name...(null)
back to cfun's name at the end ..wwoohoho

I was reading around, that arrays pass by reference to a function in C. So how come after I clear up the array in cfun2, I still get to see the string after exiting cfun2 and back to cfun?

[donbock]

cfun allocates 20 bytes of heap storage and stores the pointer to that allocation in pointer variable name. Normally I would warn you to test the malloc return value to make sure it was successful, but in this case it doesn't matter. The next thing it does is throw away that value when it overwrites name with the pointer to a string constant that holds "wwoohoho".

You should have gotten a runtime error when cfun2 called free. The pointer passed to free is the string constant, not the memory allocated by malloc in cfun. Furthermore, the final printf in cfun2 should also have provoked a runtime error when it dereferenced pointer name2 after it was set to NULL.

Probably you meant to do the following instead of the assignment in cfun.

strcpy(name, "wwoohoho");

[adrivetest]

donbock, im not sure why im not getting any runtime error, im actually using pellesC for windows to try it out. I'm not too familiar with C, please bare with me..

The purpose of this scenario is because I wanted to find out what happens if a caller calls a function that tries to free up the pointer it passes in to. In this case, cfun2 tries to free up cfun's allocated heap.

I also wanted to know if the the 'name' in cfun and 'name2' in cfun2 is actually pointing to the same address..because im assuming 'name' was passed by reference into cfun2 and thus they're not local variables inside their own function.

By right, printf("back to cfun's name at the end ..%s\n",name); should just produce an error since it was freed inside cfun2

[jhumelsine]

It's been a long time since I coded in C. I'm mostly in C++ now, so please take this comment with a grain of salt.

I think that C passes by value, so name2 = NULL may only be setting parameter to NULL, not the original name argument.

If that's the case, then name is still pointing to the same block of memory, whether it's free or not. You might be able to confirm this by printing the address of name (&name, I think), both before and after the call to cfun2.

If my hunch is correct, then name has become a dangling reference. The reason you're still seeing it print out wwoohoho is because it is still pointing to the same memory as before. While this memory has been freed, it has not been allocated to anything else.

You're lucky... well actually you're unlucky, because this is a land mine waiting to blow up.

Eventually, that memory will be reallocated to something else. Then when the printf occurs, it could core dump. The real headache is that you don't know where it may or may not core dump. It could be in your code, or your code could change that memory and the other program using it will core dump, and that poor developer will be left scratching his head wondering why his code core dumped when everything looked fine.

Because of this I STRONGLY suggest that you alwasy allocate and free memory in the same relative stack depth where possible, and even in the same method where possible. This isn't always possible, but when one method allocates memory and another one frees it, you run a much greater risk of having a memory issue.

NOTE: You could run into similar issues by declare a pointer, but not allocating any space for it. If the point just happens to be pointing to memory that "works" for your application, it will appear to work. If it's pointing to something else, it won't work and it won't work badly. Unfortunately, "working" vs "not working" is somewhat random. Not working is much better, because you have a better chance to find your problem and correct it.

[donbock]

int main () { 
    cfun(); 
    return 0; 
} 
 
void cfun(void) { 
    char *name; 
    name = (char *)malloc(20*sizeof(char)); 
    name = "wwoohoho"; 
    cfun2(name); 
    printf("back to cfun's name at the end ..%s\n",name); 
} 
 
void cfun2(char *name2) { 
    printf("in...%s\n",name2); 
    free(name2); 
    name2 = NULL; 
    printf("cfun2 after freeing name...%s\n",name2); 
}

• The assignment causes line 9 to lose track of the memory allocated by line 8. This is a classic memory leak.
• Line 16 tries to free the constant string "wwoohoho". What happens when you try to free memory that hasn't been allocated is undefined. Some systems would give you a runtime error.
• Line 18 dereferences the NULL pointer. This pointer doesn't point anywhere. What happens is undefined. Some systems would give you a runtime error.
• Line 11 -- notice that name still points at the string constant so of course this line still prints out "wwoohoho".

[adrivetest]

It passes by value? does this mean freeing the pointer memory on cfun2 and cfun are totally independent of each other?


i'm trying to find out whether this is the case because im worried that if a pointer to a string was passed into a function but was freed by its called function and someone tries to use the pointer after the called function...is that gonna be a problem? If it's by value..i don't think so, if it's by reference..then yes.