1. 1 240-222 CPT: Ptr+Str/11 240-222 Computer Programming Techniques Semester 1, 1998 Objective of these slides: –to discuss how pointers are used with structs 11. Pointers and Structures

2. 2 240-222 CPT: Ptr+Str/11 Overview 1.A struct can contain Strings 2.Shuffling Cards 3.Pointers to structs 4.Updating a struct

3. 3 240-222 CPT: Ptr+Str/11 1. A struct can Contain Strings struct card{ char *face; char *suit; }; : struct card a = {"Three", "Hearts"}; : printf("%s", a.suit); /* prints Hearts */

4. 4 240-222 CPT: Ptr+Str/11 2. Shuffling CardsSec. 10.7 2. Shuffling CardsSec. 10.7 #include #include #include struct card { char *face; char *suit; }; typedef struct card Card; void filldeck(Card [], char *[], char *[]); void shuffle(Card []); void deal(Card []); continued

5. 5 240-222 CPT: Ptr+Str/11 int main() { Card deck[52]; char *face[] = {"Ace", "Deuce", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine","Ten","Jack", "Queen", "King"}; char *suit[] = {"Hearts", "Diamonds", "Clubs", "Spades"}; srand(clock());/* set random num */ filldeck(deck, face, suit); shuffle(deck); deal(deck); return 0; } continued

6. 6 240-222 CPT: Ptr+Str/11 void filldeck(Card wdeck[], char *wface[], char *wsuit[]) /* initialise the deck of cards */ { int i; for (i = 0; i <= 51; i++) { wdeck[i].face = wface[i % 13]; wdeck[i].suit = wsuit[i / 13]; } } continued

7. 7 240-222 CPT: Ptr+Str/11 void shuffle(Card wdeck[]) /* randomly rearrange the deck of cards */ { int i, j; Card temp; for (i = 0; i <= 51; i++) { j = rand() % 52; /* get rand num */ if (i != j) { temp = wdeck[i]; wdeck[i] = wdeck[j]; wdeck[j] = temp; } } } continued

8. 8 240-222 CPT: Ptr+Str/11 void deal(Card wdeck[]) /* display the deck */ { int i; for (i = 0; i <= 51; i++) printf("%5s of %-8s%c", wdeck[i].face, wdeck[i].suit, (i + 1) % 2 ? '\t' : '\n'); }

9. 9 240-222 CPT: Ptr+Str/11 Output (see fig. 10.4): Eight of DiamondsAce of Hearts Eight of ClubsFive of Spades : :

10. 10 240-222 CPT: Ptr+Str/11 3. Pointers to Structs struct card a, *c; a = {"Four", "Spades"}; c = &a; : printf("%s", c->suit); /* prints Spades */ c->suit is equivalent to (*c).suit

11. 11 240-222 CPT: Ptr+Str/11 #include /* fig 10.2 */ struct card { char *face; char *suit; }; continued Example

12. 12 240-222 CPT: Ptr+Str/11 int main() { struct card a; struct card *aptr; a.face = "Ace"; a.suit = "Spades"; aptr = &a; printf("%s of %s\n%s of %s\n%s of%s\n", a.face, a.suit, aptr->face, aptr->suit, (*aptr).face, (*aptr).suit); return 0; }

13. 13 240-222 CPT: Ptr+Str/11 Output: Ace of Spades Ace of Spades Ace of Spades

14. 14 240-222 CPT: Ptr+Str/11 4. Updating a struct l Code fragment: struct card { char *face; char *suit; }; int main() { struct card a; a.face = “Three; printf(“%s”, a.face); }

15. 15 240-222 CPT: Ptr+Str/11 Discussion l This code works, so what is the problem? Answer: the scope of “Three” –at the end of main(), “Three” goes out of scope and is deleted –this does not matter for this example because the scope of main() is the entire program

16. 16 240-222 CPT: Ptr+Str/11 A More Dangerous Example int main() { struct card a; a = initialise(); printf(“%s”, a.face); : printf(“%s”, a.face); } struct card initialise(void) { struct card b; b.face = “Three”; return b; }

17. 17 240-222 CPT: Ptr+Str/11 Discussion The scope of “Three” is initialise(), and so will be deleted after initialise() returns –return copies out the b struct, including its two pointers –a is assigned the pointers, but what do they point at? –the deletion may not happen immediately, but depend on the memory usage of the rest of the program the first printf() may work, sometimes!

18. 18 240-222 CPT: Ptr+Str/11 First Solution struct card1( char face[10]; char suit[10]; }; int main() { struct card1 a; a = initialise1(); : printf(“%s”, a.face); } struct card1 initialise1(void) { struct card1 b; strcpy(b.face, “Three”); return b; }

19. 19 240-222 CPT: Ptr+Str/11 Discussion l The general solution is to make a copy of the string –“Three” is copied into the fixed size array b.face using strcpy() –that array is copied out as part of the b struct using return

20. 20 240-222 CPT: Ptr+Str/11 Second Solution struct card( char *face; /* no fixed size */ char *suit; }; int main() { struct card a; a = initialise2(); : printf(“%s”, a.face); } struct card initialise2(void) { struct card b; b.face = (char *)malloc(6); strcpy(b.face, “Three”); return b; }

21. 21 240-222 CPT: Ptr+Str/11 Discussion The second solution still uses copying, but now calls malloc() to make dynamic memory –return only copies out the pointers inside b –but malloc’ed memory is not deleted even though the scope of b is initialise2() –so a.face will point to the malloc’ed memory from initialise2()

22. 22 240-222 CPT: Ptr+Str/11 Third Solution struct card( char *face; /* no fixed size */ char *suit; }; int main() { struct card a; initialise3(&a); : printf(“%s”, a.face); } void initialise3(struct card *ap) { ap->face = (char *)malloc(6); strcpy(ap->face, “Three”); }

23. 23 240-222 CPT: Ptr+Str/11 Discussion The third solution uses malloc() to make dynamic memory, but for the a struct. –pass in a pointer to a, and alter a via the pointer (this is how C implements call-by-reference). –this is the most common coding style for manipulating structs inside functions