Thread: Passing Pointers???

Code:

void test(char *testptr)
{
	testptr = "hello world";
	
	// 2. GDB says tesptr has value: 0x80487cc "hello world"
}

int main()
{
	char *testptr;

	// 1. GDB says testptr has value: 0x8006d0 and a bunch of crap: U\211aWVSeo\224

	test(testptr);
	
	// 3. GDB says testptr again has value 0x8006d0 and a bunch of crap: U\211aWVSeo\224
}

Why is the pointer not keeping its value????

Don't think I understand the question; what value are you referring to?

To retain the value you either have to return the pointer from the function, or pass it by reference. You also arent allocating any space to hold your string; this is a bad thing btw.

Don't think I understand the question; what value are you referring to?

testptr

I pass it to function. It gets the correct value.

Back in main it has crap value.

Why doesn't it retain the value set in the function?

Heres how you pass by reference:

Code:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MAX_LEN 50

void test(char **testptr)
{
	strncpy(*testptr, "goodbye world", MAX_LEN);
}

int main()
{
    char* testptr = (char*)malloc(MAX_LEN+1); 
    strncpy(testptr, "hello world", MAX_LEN);
    printf("%s\n", testptr);

    test(&testptr);
    printf("%s\n", testptr);	
    
    free(testptr);

}

Theres some extra stuff in the code that you should get your head around if you want to work with strings in C. Basically allocating/freeing space and making sure you dont get buffer overflows.

Thank you! The extra * in void test(char **testptr) along with the & in main was what I needed! Perfect!

Elysia - you forgot the & in test(&testptr);

Anytime

Hello,

I have always had trouble with pointer to pointers. Especially when using a char.

So I tried it without the pointer to pointer. However, I got printed out a load of rubbish in my printf statement.

Code:

void test(const char *testptr)
{
    testptr = "hello world";
}

int main(void)
{
    const char *testptr;
    test(testptr);

    printf("testptr: %s\n", testptr);

    return 0;
}

I understand that a pointer to pointer is a pointer that points to another pointer.

So here you are passing the address of the pointer:
test(&testptr)

So here you are dereferencing the pointer and assigning a string.
*testptr = "hello world";

Which basically is like doing this, declaring and initializing a pointer to a string
char *mytest = "hello world";

But why would you need a pointer to pointer. Can't the same thing be done without one.

Correct me if I am wrong with the above examples.

Just one more question. Why have you got const
const char *testptr.

Is this so that the pointer cannot point to another datatype i.e. int, float, etc.

Many thanks correcting my understanding.

It has to be done in this case because you are passing the pointer to a function which is always by value...

here's a link that may be useful...

http://www.augustcouncil.com/~tgibson/tutorial/ptr.html

When you pass the pointer to the function, like you did originally, the compiler creates a COPY of that pointer. So any chages made to this copy will not change the original. When you pass the address of the original pointer into the function, any changes you make are now being made to the original address and therefore to the original pointer.

You could just use a pointer. But if you did so, the change to testptr would not be seen in main. Nothing passed in to a function can be changed, but you can use the address to change what is pointed to.

And const just means that the chars cannot be changed. "hello world" is a pointer to constant characters, so that's the type we use.