{"id":2310,"date":"2017-01-28T00:01:13","date_gmt":"2017-01-28T08:01:13","guid":{"rendered":"http:\/\/c-for-dummies.com\/blog\/?p=2310"},"modified":"2017-02-04T07:48:40","modified_gmt":"2017-02-04T15:48:40","slug":"manipulate-pointers-in-functions-part-iii","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=2310","title":{"rendered":"Manipulate Pointers in Functions, Part III"},"content":{"rendered":"

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 **<\/code> 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.
\n
\nLike every variable type, a pointer has an address in memory, a location. So when you create char<\/em> pointer *text<\/code>, 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.<\/p>\n

From the sample program from last week’s Lesson<\/a>, variable *text<\/code> is inialized to a string buffer in the main()<\/em> function:<\/p>\n

char *text = \"ABCD\\n\";<\/code><\/p>\n

When variable text<\/code> is used, it refers to the starting location, the memory address, where \"ABCD\\n\"<\/code> is located.<\/p>\n

When variable *text<\/code> is used, it references the character (because text<\/code> is a char<\/em> pointer) at the memory address stored in text<\/code>, which would be the character 'A'<\/code>. Figure 1 illustrates this concept.<\/p>\n

\"\"

Figure 1. The pointer variable text<\/code> contains an address; variable *text<\/code> references the contents of that address.<\/p><\/div>\n

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<\/a>. 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.<\/p>\n

When you need to manipulate a pointer’s address in a function, pass a pointer to the pointer.<\/p>\n

Bear with me.<\/p>\n

You start by getting the address of the pointer variable: Use the &<\/code> operator just as you would on any other variable. Figure 2 illustrates.<\/p>\n

\"\"

Figure 2. The memory location of variable text<\/code>, which holds the address of string \"ABCD\\n\"<\/code>.<\/p><\/div>\n

In Figure 2, you see the address of pointer text<\/code>, which is shown as value 0x7FE88<\/code>. The contents of that location are the address of the string \"ABCD\\n\"<\/code>, or 0x7FF00<\/code>, which is illustrated in Figure 1.<\/p>\n

The pointer’s address by itself is a curiosity, but the value can be saved in a pointer-pointer variable. The char<\/em> variable **p<\/code> is designed to hold the address of a pointer, or the address of (*<\/code>) the address of (*<\/code>) some variable.<\/p>\n

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.<\/p>\n

To make the &text<\/code> address value useful, last week’s program created the **p<\/code> variable. It’s assigned to the value of &text<\/code> when that value is passed to the fourchar()<\/em> function. As a statement, the assignment looks like this:<\/p>\n

p = &text;<\/code><\/p>\n

Figure 3 illustrates all the gears and cogs of this machination.<\/p>\n

\"\"

Figure 3. How the *text<\/code> and **p<\/code> variables work together.<\/p><\/div>\n

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.<\/p>\n

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<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"

Pointers and pointers-to-pointers and addresses of pointers and all that stuff explained. Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[],"class_list":["post-2310","post","type-post","status-publish","format-standard","hentry","category-main"],"_links":{"self":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/2310","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=2310"}],"version-history":[{"count":7,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/2310\/revisions"}],"predecessor-version":[{"id":2364,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/2310\/revisions\/2364"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=2310"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=2310"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=2310"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}