{"id":2695,"date":"2017-09-16T00:01:42","date_gmt":"2017-09-16T07:01:42","guid":{"rendered":"http:\/\/c-for-dummies.com\/blog\/?p=2695"},"modified":"2017-09-23T07:50:44","modified_gmt":"2017-09-23T14:50:44","slug":"pointers-on-pointers-in-structures","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=2695","title":{"rendered":"Pointers on Pointers in Structures"},"content":{"rendered":"

Structures are the complex variable type in C, allowing you to craft data-rich units for storing and retrieving all sorts of interesting information. They’re fun! But like asterisks falling as snowflakes, sprinkle some pointers into a structure and you can get into trouble fast.
\n
\nIt comes down to a battle between the .<\/code> and -><\/code> operators, both of which reference structure members. The .<\/code> operator is the one that you’re glad to use. The -><\/code> implies that a pointer lurks somewhere in the structure. But where?<\/p>\n

This code employs a structure variable to store a person’s name. It contains two members, char<\/em> arrays first<\/code> and last<\/code>:<\/p>\n

\r\n#include <stdio.h>\r\n#include <string.h>\r\n\r\nint main()\r\n{\r\n    struct name {\r\n        char first[24];\r\n        char last[24];\r\n    };\r\n    struct name me;\r\n\r\n    strcpy(me.first,\"Dan\");\r\n    strcpy(me.last,\"Gookin\");\r\n\r\n    printf(\"Hello, %s %s!\\n\",\r\n            me.first,\r\n            me.last);\r\n\r\n    return(0);\r\n}<\/pre>\n
Lines 12 and 13 copy constant strings into the array; both use the .<\/code> member operator. Here’s the output:<\/p>\n
Hello, Dan Gookin!<\/code><\/pre>\n
Now hide behind your chair. For a pointer version of the code, you have several options: pointer structure, pointer members, or both pointer structure and pointer members.<\/p>\n
The first option is to make the structure itself a pointer:<\/p>\n
\r\n#include <stdio.h>\r\n#include <stdlib.h>\r\n#include <string.h>\r\n\r\nint main()\r\n{\r\n    struct name {\r\n        char first[24];\r\n        char last[24];\r\n    };\r\n    struct name *me;\r\n\r\n    me = (struct name *)malloc(1 * sizeof(struct name));\r\n    if( me==NULL )\r\n    {\r\n        puts(\"Unable to allocate memory\");\r\n        return(1);\r\n    }\r\n\r\n    strcpy(me->first,\"Dan\");\r\n    strcpy(me->last,\"Gookin\");\r\n\r\n    printf(\"Hello, %s %s!\\n\",\r\n            me->first,\r\n            me->last);\r\n\r\n    return(0);\r\n}<\/pre>\n
The name<\/code> structure pointer me<\/code> is declared at Line 11. It’s just a pointer, a storage container for a memory location.<\/p>\n
At Line 13, the malloc()<\/em> function sets aside space for the name<\/code> structure and saves that location in me<\/code>. Because me<\/code> is a pointer, the -><\/code> operator must be used to address its members. You see that operator in Lines 20, 21, 24, and 25.<\/p>\n
The program’s output is the same as the first example.<\/p>\n
Now consider this code, where the members are pointers, but the structure isn’t:<\/p>\n
\r\n#include <stdio.h>\r\n#include <stdlib.h>\r\n#include <string.h>\r\n\r\nint main()\r\n{\r\n    struct name {\r\n        char *first;\r\n        char *last;\r\n    };\r\n    struct name me;\r\n\r\n    me.first = (char *)malloc( sizeof(char) * 24 );\r\n    me.last = (char *)malloc( sizeof(char) * 24 );\r\n    if( me.first==NULL || me.last==NULL)\r\n    {\r\n        puts(\"Unable to allocate memory\");\r\n        return(1);\r\n    }\r\n\r\n    strcpy(me.first,\"Dan\");\r\n    strcpy(me.last,\"Gookin\");\r\n\r\n    printf(\"Hello, %s %s!\\n\",\r\n            me.first,\r\n            me.last);\r\n\r\n    return(0);\r\n}<\/pre>\n
The malloc()<\/em> statements at line 13 and 14 assigns storage to the first<\/code> and last<\/code> pointers. Because the structure itself isn’t a pointer, the standard member operator (.<\/code>) is used.<\/p>\n
Finally, here’s a beast:<\/p>\n
\r\n#include <stdio.h>\r\n#include <stdlib.h>\r\n#include <string.h>\r\n\r\nint main()\r\n{\r\n    struct name {\r\n        char *first;\r\n        char *last;\r\n    };\r\n    struct name *me;\r\n\r\n    me = (struct name *)malloc( sizeof(struct name) * 1);\r\n    if( me==NULL )\r\n    {\r\n        puts(\"Unable to allocate memory\");\r\n        return(1);\r\n    }\r\n    me->first = (char *)malloc( sizeof(char) * 24 );\r\n    me->last = (char *)malloc( sizeof(char) * 24 );\r\n    if( me->first==NULL || me->last==NULL)\r\n    {\r\n        puts(\"Unable to allocate memory\");\r\n        return(1);\r\n    }\r\n\r\n    strcpy(me->first,\"Dan\");\r\n    strcpy(me->last,\"Gookin\");\r\n\r\n    printf(\"Hello, %s %s!\\n\",\r\n            me->first,\r\n            me->last);\r\n\r\n    return(0);\r\n}<\/pre>\n
Everything’s a pointer!<\/p>\n
The me<\/code> structure, as well as its members, must be allocated storage. The pointer me<\/code> is done first, otherwise memory can’t be allocated for its members. The -><\/code> member operator is required because structure me<\/code> is a pointer — and that’s the only reason. If only the members were pointers, as shown in the earlier example, you use the standard .<\/code> member operator.<\/p>\n
I hope these examples help you to understand how pointers operate within a structure. The knots get tighter when you mix structures within structures along with pointers. That dangerous ground I cover in next week’s Lesson<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"
It’s madness! The multivariable features too many options for messing with pointers. 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-2695","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\/2695","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=2695"}],"version-history":[{"count":8,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/2695\/revisions"}],"predecessor-version":[{"id":2722,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/2695\/revisions\/2722"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=2695"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=2695"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=2695"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}