It’s common to pass a pointer to a function. Within the function, you can manipulate the data the pointer references without having to return that data from the function. This aspect of a pointer is what makes C a powerful — and scary — programming language. But what about when you need to manipulate the pointer’s address in the function?
\n
\nWhile you can manipulate the data a pointer references, within a function you cannot manipulate the pointer itself (its address). That’s because the function doesn’t “own” the pointer variable; it uses a copy. Like any other variable passed to a function, the original variable is unchanged unless it’s a global (external) variable.<\/p>\n
Pointers are confusing enough without having to add another layer of complexity, but occasionally I run into these types of puzzles. You will, too, unless you forget how variables are passed to functions and your brilliant program doesn’t work.<\/p>\n
As is usually the case, it’s best to show sample code to illustrate the problem:<\/p>\n
\r\n#include <stdio.h>\r\n\r\nvoid fourchar(char *p)\r\n{\r\n int x;\r\n\r\n for(x=0;x<4;x++)\r\n {\r\n putchar(*p);\r\n p++;\r\n }\r\n}\r\n\r\nint main()\r\n{\r\n char *text = \"ABCD\\n\";\r\n\r\n fourchar(text);\r\n putchar(*text);\r\n\r\n return(0);\r\n}<\/pre>\nString text<\/code> is declared as a pointer in the main()<\/em> function. Its address (text<\/code>) is passed to function fourchar()<\/em>, which manipulates the pointer to display four characters in the string. In the function, each character is referenced by *p<\/code> and pointer p<\/code> is incremented.<\/p>\nWhen fourchar()<\/em> returns, the putchar()<\/em> function displays the character *text<\/code>. You might think that because p<\/code> was incremented in the fourchar()<\/em> function, that the value of text<\/code> was also manipulated. If so, *text<\/code> references the '\\n'<\/code> character in the string. But it doesn’t, as the program’s sample output shows:<\/p>\nABCDA<\/code><\/pre>\nThe problem isn’t that the pointer is called p<\/code> in function fourchar()<\/em> and text<\/code> in main()<\/em>; they are two different variables. No, the problem is that only the pointer’s address is passed to the function; the pointer variable itself remains intact and unchanged inside the main()<\/em> function. This aspect holds true for all variables passed to functions, but it’s extra weird because you can still manipulate a pointer’s referenced data.<\/p>\nBottom line: When the fourchar()<\/em> function returns, the putchar()<\/em> statement displays the 'A'<\/code> in string text<\/code>. That’s because the address in text<\/code> hasn’t been changed within the main()<\/em> function.<\/p>\nStill, after all this explaining and understanding, I have a question: How can the code manipulate a pointer within a function and have that manipulation stick?<\/p>\n
For example, I want the fourchar()<\/em> function to adjust the value of the text<\/code> pointer and have that manipulation retained when the function call returns. Such a thing is possible, and I’ll explore that solution in next week’s Lesson<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"Pointers passed to functions transform into local variables, which can frustrate your otherwise well-laid plans. Continue reading