When a function must manipulate a pointer’s address, the argument passed is a pointer-pointer, not a pointer. Confused? Oh, I’m just getting started . . .
\n
\nAs a review:<\/p>\n
Manipulating the contents of a pointer in a function is easy. To manipulate the pointer’s address, however, you must pass the pointer’s address, or a pointer-pointer, to the function.<\/p>\n
It’s true: Like every other variable type, pointers have addresses in memory.<\/p>\n
In last week’s Lesson<\/a>, the pointer And this statement calls the function from main()<\/em>:<\/p>\n Within the function, you use pointer The address of Yes, it’s the ugly The following modification to last week’s code accepts a pointer-to-a-pointer as an argument to the fourchar()<\/em> function, manipulates the pointer’s address directly, as well as displays the contents of the pointer-to-a-pointer address:<\/p>\n Within function fourchar()<\/em>, the character at Within the fourchar()<\/em> function, variable The next line manipulates the address stored in In the main()<\/em> function, you’d use Here’s sample output:<\/p>\n Unlike last week’s code, the pointer’s address is changed within the fourchar()<\/em> function. When the function returns, the address stored in I’ll explain the pointer-to-pointer relationship in further detail, along with friendly illustrations, in next week’s Lesson<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":" You can’t change a pointer’s address in a function, but you can change a pointer-to-a-pointer’s address. Continue reading text<\/code> is passed to function fourchar()<\/em>. Here’s the declaration of that function:<\/p>\nvoid fourchar(char *p)<\/code><\/p>\nfourchar(text);<\/code><\/p>\np<\/code> to manipulate values at memory location text<\/code>. You can change pointer p<\/code> in the function, but the original pointer text<\/code> dwells in the main()<\/em> function unchanged — that is, unless you pass its address to the function. To do so, you use this statement in main()<\/em>:<\/p>\nfourchar(&text);<\/code><\/p>\ntext<\/code> can be manipulated in function fourchar()<\/em>. The declaration of fourchar()<\/em> must be changed to accept the new variable type:<\/p>\nvoid fourchar(char **p)<\/code><\/p>\n**<\/code> operator that drives everyone nuts, but that’s how you can modify a pointer’s address — as well as the contents at that address — within a function. Indeed, things get truly ugly in this operation, but they’re still workable.<\/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>\n*text<\/code> is referenced as **p<\/code>. This is where some programmers doze off, but pay attention! **p<\/code> translates as, “The contents of the address stored at address p<\/code>.”<\/p>\n*p<\/code> is a memory location, not a character. It holds the value passed to the function, the address of pointer text<\/code>. To access that memory location’s value, what would be *text<\/code> in the main()<\/em> function, you use **p<\/code> in function fourchar()<\/em>.<\/p>\n*p<\/code> — the value of the main()<\/em> function’s text<\/code> pointer variable:<\/p>\n(*p)++;<\/code><\/p>\ntext++<\/code>, but because the address of text<\/code> was passed to the fourchar()<\/em> function, you need to use a pointer, *p<\/code>. Further, because of the order of precedence, you must ensure that the pointer at *p<\/code> is incremented, so you need parentheses: (*p)++<\/code>.<\/p>\nABCD<\/code><\/pre>\ntext<\/code> references the newline character, which is displayed in the output.<\/p>\n