Pass by Reference with a pointer to char

I'm relatively new to C and I was pretty sure I had a decent understanding of pointers and how they are used. However, I was just playing around with the concept of Pass by Reference and came across a bit of a delima. Hopefully someone can help explain this to me....

I have 2 small programs to test my knowledge of pass by reference and I wanted them both to have the same results however they do not:

Program 1

Code:

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

int main(){

 char* hostname= (char*)calloc(10, sizeof(hostname));
 hostname = "unchanged";
 printf("Address of hostname = %d\n", &hostname);
 someFunction(&hostname);
 printf("Hostname: %s\n", hostname);
 return 0;

}


someFunction(char** s){

   printf("s = %d\n", s);
   printf("Address of s = %d\n", &s);
   printf("*(&s) = %d\n", *(&s));
   *s = "changed";
}

Program 2

Code:

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

int main(){
 char* hostname = (char*)calloc(10, sizeof(hostname));
 hostname = "unchanged";
 printf("Address of hostname = %d\n", &hostname);
 someFunction(&hostname);
 printf("Hostname: %s\n", hostname);
 return 0;
}


someFunction(char* s){

   printf("s = %d\n", s);
   printf("Address of s = %d\n", &s);
   printf("*(&s) = %d\n", *(&s));
   *(&s) = "changed";

}

The results of Program 1 gives me what I expected which was hostname being changed to "change":

Address of hostname = -1073845548
s = -1073845548
Address of s = -1073845584
*(&s) = -1073845548
Hostname: changed

The results of Program 2 do not give me what I expected. Can someone please tell my why hostname does not get "changed" in this example?

Address of hostname = -1074574892
s = -1074574892
Address of s = -1074574928
*(&s) = -1074574892
Hostname: unchanged

* and & "eat" each other, so *(&s) is the same as s (in fact, the standard says that a compiler is free to pretend you typed s, and doesn't have to fetch the pointer+dereference if it doesn't want to), so this is the same as typing "s = "changed";" and as you know changes made to the parameter (in this case s) are not seen in the calling function.

Code:

char* hostname= (char*)calloc(10, sizeof(hostname)); // allocates
hostname = "unchanged"; // memory leak

*(&s) is no different from simply s, or for that matter *(&(*(&(*(&s))))

Don't use this to print an address:

>> printf("s = %d\n", s);

Instead:

printf("s = %x\n", s);

The second version of 'someFunction' expects a char*, but you pass it a char**.

My advice to you would be to spend a bit more time with your C programming text on pointers...

Hmm ok I understand that part I think...I had initially tried to do it like this but got a compile error:

Code:

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

int main(){
 char* hostname = (char*)calloc(10, sizeof(hostname));
 hostname = "unchanged";
 printf("Address of hostname = %d\n", &hostname);
 someFunction(&hostname);
 printf("Hostname: %s\n", hostname);
 return 0;
}


someFunction(char* s){

   printf("s = %d\n", s);
   printf("Address of s = %d\n", &s);
   printf("*(&s) = %d\n", *(&s));
   *s = "changed";

}

passbyref.c: In function `someFunction':
passbyref.c:19: warning: assignment makes integer from pointer without a cast

Any idea why this doesn't work?

Originally Posted by JoshNCSU22

Hmm ok I understand that part I think...I had initially tried to do it like this but got a compile error:

Code:

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

int main(){
 char* hostname = (char*)calloc(10, sizeof(hostname));
 hostname = "unchanged";
 printf("Address of hostname = %d\n", &hostname);
 someFunction(&hostname);
 printf("Hostname: %s\n", hostname);
 return 0;
}

someFunction(char* s){

   printf("s = %d\n", s);
   printf("Address of s = %d\n", &s);
   printf("*(&s) = %d\n", *(&s));
   *s = "changed";

}

passbyref.c: In function `someFunction':
passbyref.c:19: warning: assignment makes integer from pointer without a cast

Any idea why this doesn't work?

Because it tries to assign a pointer ("changed" is a pointer-to-const-char) to an integral type (*s is just a char).

Code:

*s = "changed";

s is a char * so *s is a char. "changed" in that context is a pointer to an array of characters. So you are trying to assign a pointer to a char (which is an integer).

There are two options here: Either pass in a pointer to the pointer to char, so that you can change the pointer to char to a different address - which if your original pointer is malloc'd, you'd leak it if you change the pointer.

The second option is that you keep the pointer pointing to the same address, but update the content of that address. In this case, you will need to fix the code in main so that you use strcpy(hostname, "unchanged") instead of just pointing to the location of the constant "unchanged", since the latter should not be changed.

--
Mats

If you assign string literals, the type should be const char*, not char*.
And realize that string literals are pointers! So you allocate memory and assign its address to a pointer, then you later assign a new address to the pointer, overwriting the old address. Memory leak!
You cannot assign strings in C, you can only assign string literals. What does this mean? You can assign the address of a string (string literal) to a pointer, but you cannot copy a string you assignment:

Code:

char arr[50];
arr = "My string"; // Error, cannot copy string
const char* p;
p = "My string"; // OK, assigns the address where "My string" resides to p.
char* p2;
p2 = "My string"; // Bad, string literals should be const.
p2 = malloc(50);
p2 = "My string"; // Bad, memory leak.

To copy a string, use strcpy.

Mmm, depends. If you're just working with string literals (and the op is) then a simple assignment is all that's necessary.

const char * s = "foo";
const char ** t = s;
*t = "bar";

like that.

Sebastiani,

Just so I understand why ' hostname = "unchanged" ' is memory leak...

Is that because hostname is a pointer to char and "unchanged" is also a pointer to char, then I allocate memory for hostname and then set it equal to another pointer? Sorry if that's way off I would just like to understand the issue better.

Whoops just saw the latest posts from Elysia...let me take all that in

Originally Posted by citizen

Mmm, depends. If you're just working with string literals (and the op is) then a simple assignment is all that's necessary.

const char * s = "foo";
const char ** t = s;
*t = "bar";

like that.

Yeah, it is. They should be const, though, as noted, so you don't make mistakes of assigning or copying into them.

>> Just so I understand why ' hostname = "unchanged" ' is memory leak...
Well, yes. It is your responsibility to free what you allocate. So if you allocate a pointer and later assign it a different address, the memory you allocated is inaccessible. It's called a memory leak because that is wasting your resources and you won't get that data back.

>> Yeah, it is. They should be const, though, as noted, so you don't make mistakes of assigning or copying into them.
const data are const so that you don't edit the data. Copying and assigning wholesale is fine.

Thanks for clarifying on the memory leak part. I understand now why it's leak; I didn't realize before that string literal actually was a pointer and allocated it's own memory like that. So if I declare something as const char *s = "string"; I don't really need to allocate any memory for it right? That gets take care of automatically?

Originally Posted by citizen

>> Yeah, it is. They should be const, though, as noted, so you don't make mistakes of assigning or copying into them.
const data are const so that you don't edit the data. Copying and assigning wholesale is fine.

Yeah, so you don't modify it by mistake. The compiler will allow copying and assigning pointers (and string literals) still.

Originally Posted by JoshNCSU22

Thanks for clarifying on the memory leak part. I understand now why it's leak; I didn't realize before that string literal actually was a pointer and allocated it's own memory like that. So if I declare something as const char *s = "string"; I don't really need to allocate any memory for it right? That gets take care of automatically?

You only seem to misunderstand one thing: string literals do not allocate data.
The reside in a read-only section and its address is stored in the pointer it's assigned to, so it should be const char*, since modifying (or trying to) the data will create a seg fault.