I know C programmers who make it their goal to avoid pointers — even where necessary. It’s possible to do so, and many have cheat sheets to help them. Then comes the **
pointer monster, which can be avoided altogether . . . until you need to manipulate a pointer variable’s own address within a function. Then you’re cursed.
Like every variable type, a pointer has an address in memory, a location. So when you create char pointer *text
, the program requests that a pointer-sized chunk of memory be set aside. When that pointer is initialized, the address of the variable it references is stored in its chunk-o-memory.
From the sample program from last week’s Lesson, variable *text
is inialized to a string buffer in the main() function:
char *text = "ABCD\n";
When variable text
is used, it refers to the starting location, the memory address, where "ABCD\n"
is located.
When variable *text
is used, it references the character (because text
is a char pointer) at the memory address stored in text
, which would be the character 'A'
. Figure 1 illustrates this concept.
To manipulate the contents of the pointer’s address in a function, you just pass the pointer. That’s what I showed in Part I of this series. But I also demonstrated that you can’t manipulate the pointer’s address; it’s unaffected because the function doesn’t own the pointer variable.
When you need to manipulate a pointer’s address in a function, pass a pointer to the pointer.
Bear with me.
You start by getting the address of the pointer variable: Use the &
operator just as you would on any other variable. Figure 2 illustrates.
In Figure 2, you see the address of pointer text
, which is shown as value 0x7FE88
. The contents of that location are the address of the string "ABCD\n"
, or 0x7FF00
, which is illustrated in Figure 1.
The pointer’s address by itself is a curiosity, but the value can be saved in a pointer-pointer variable. The char variable **p
is designed to hold the address of a pointer, or the address of (*
) the address of (*
) some variable.
This is spot where programmers become overwhelmed, which is easy to do to. References to references are something that human brains don’t regularly deal with.
To make the &text
address value useful, last week’s program created the **p
variable. It’s assigned to the value of &text
when that value is passed to the fourchar() function. As a statement, the assignment looks like this:
p = &text;
Figure 3 illustrates all the gears and cogs of this machination.
The goal of all these words and illustrations is that if you can’t get your head wrapped around the pointer-pointer concept, at least you can look up a handy reference that explains how the various pieces work. That’s what I do in Figure 3, which is often what I write down while I’m programming so that I can use the proper references.
And now the Big Reveal: The pointer and pointer-pointer relationship has a lot to do with two-dimensional arrays. I cover this topic in next week’s Lesson.