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.

Quote:

---

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?

Quote:

---

Originally Posted by mike_g

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.

---

How do I pass it by reference?

I tried test( &testptr ) but that gives a warning: passing argument 1 of \u2018test\u2019 from incompatible pointer type

And still doesn't save the value either =\

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!

Code:

---

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

int main()
{
        const char* testptr;
        test(&testptr);
}

---

http://cboard.cprogramming.com/showp...30&postcount=5
String literals should be const char

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

Yes, silly me. I just copied and pasted >_<
Phew. Thanks for the correction.

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.

Quote:

---

Originally Posted by steve1_rm

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

---

Because of the reason I explained in the link I posted. Did you not read it or did you not understand it?
And no, it can't be done without.

Quote:

---

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.

---

Again, because of the reason explained on the wiki link I posted. Did you not read it or did you not understand it?
It's so that you won't accidentally modify the contents of what the pointer points to.