 Consider this code, which sets up a structure to represent a book by its ISBN, title, and price. We're going to write a function that lowers the price of the book by a given percent, because structures are passed by value. The function will have to return a struct book. The name of the function will be discount, and the parameters will be the book we want to discount, and the percentage to take off the price. The body of the function sets the price of the book to be the current price times 1 minus the percent divided by 100. And then it returns the updated local copy to the caller. In the main function, we've set up a book called C-book, and we want to set it to the result of calling discount with the current value and 5% off. And then we'll print the new price by accessing the price member of C-book. Let's build this and run it, and it works great. This code isn't wrong, but if you're in a limited memory environment, again, our scarcity model, the idea that we have to copy the 100 character title from the argument into the parameter may bother you. This is a place where it might be useful to pass the address of the structure and update the structure in place. Let's make the change to the function call. Instead of returning a value, we'll pass the address of the structure we want to update. Our function now becomes a void function that does not need a return, and instead of a book structure, we have a pointer to a book, which we'll call P-book. The question now becomes, how do we access the price? You need to dereference the point rephrase. You need to dereference the pointer and here as well. But that won't quite do the trick. Because of the precedence of the operators, this would try to get the price member out of the pointer and then dereference it last. That won't work because the pointer isn't a structure. Instead, you need to use parentheses to make things happen in the correct order. The parentheses say dereference the pointer, which leads us to the book structure, and then it's okay to get the price member out of that structure. Let's build the program and run it, and it still works. Accessing a member of a dereference structure is a very common operation. So common, in fact, that there's a shortcut for it. Instead of needing the parentheses, we'll say P-book pointer to price, and we'll do that on the left-hand side also. Notice that we don't have the star operator there anymore. Rebuild, and again, it runs just as well. This is the notation you will almost always find when you read other C programmers' code, even when you're only accessing a structure rather than updating it. You'll more commonly see people pass the address of the structure. It saves both time and space. For example, this function to display a book structure takes a pointer to a book structure as its only parameter and prints the information about that book. And we'll use the arrow or pointer notation all the way through here, follow the P-book pointer and get the title member, follow the P-book pointer and get the ISBN, follow the pointer, and get the price member. Let's call that function with the address of the C-book that we constructed in main, build, and run. The arrow operator makes accessing a structure via its pointer as convenient as using the dot notation on the actual structure.