This document outlines a series of programming exercises in C, focusing on functions and input validation involving two-digit integers. It details steps for implementing user-defined functions to calculate the number of tens in a number, the remainder when divided by 10, and demonstrates the use of pointers to modify values in the main function. Additionally, it emphasizes the importance of understanding variable scope and memory management in C programming.

1. Exercise #1: Write a C program that contains the following steps (make sure all variables are int).
Read carefully each step as they are not only programming steps but also learning topics that
explain how functions in C really work. Ask the user for a number between 10 and 99. Write an
input validation loop to make sure it is within the prescribed range and ask again if not.
Commenting out the existing coding, write the code to divide a two digit integer number by 10 (pick
any number you want between 10 and 99; hard code it right into the program rather than input it).
Output the result as an integer. Try this with a few different initial numbers. For example, 59 would
give an output of 5. Next write the code to find the remainder when a two digit number (again, hard
code it into your program) is divided by 10 [note that this is done in a single statement]. Output the
result as an integer. Try this with a few different numbers. For example, 59 would give an output of
9. Comment the code from steps 4 and 5 out of your program, and put the coding to find the
number of 10's in a number into a user defined (helper) function named f1. Set the initial number
in a variable named x in the main function and print it out to check that it was set correctly). Your
code will then pass x to a variable named y in f1 - the syntax for the call is of course f1( x ); . (That
is, you are copying the value in the argument variable x into the parameter variable y.) f1 should
return the number of 10's in y. After f1 returns, the main function should print the returned value.
You should see the original number printed from the main function and the returned number of
10's in that original number, also printed from the main function. Try this with a couple of different
initial numbers. Repeat step 6 but this time put the coding of the step 5 into another user defined
(helper) function named f2. Again use y as the name of the parameter in f2; it will not get confused
with the y in f1 - they are declared in separate functions and are thus completely different
variables. (f1 has its own y and f2 has its own y.) f2 should return the remainder when the passed
(copied) number in y is divided by 10. After the setting of the initial number and printing it to check
it, the main function should invoke (call) f2, and after f2 returns the main function should print the
returned value. You should see the original number printed from the main function and the
returned remainder when that original number is divided by 10, also printed from the main
function. Try this with a couple of different initial numbers. Comment out the calls for f1 and f2.
Keep the assignment of a value to x and the print to check that it was properly set. Write a void (no
return value will be given) function f3 which will be passed the address of your initial number (x).
The syntax for the call to this function is, of course f3(&x); The function f3 will have a single
parameter, named x_address, and that parameter must be able to hold the ADDRESS of an
integer value, that address being copied from the &x. Check with you notes Ch 3 slide 7 to see
how this should be declared. By dereferencing an address (a pointer) we are accessing the value
AT that address (either getting it or setting it). Inside f3, dereference the parameter x_address (the
dereference syntax is "*x_address", with no quotes of course) and then (still inside f3) print out the
result of the dereferencing. You will see that you have obtained the value of x, which is in the main
function. After returning, the main function should print out x again. All three prints of x (the original
check in the main, inside f3 after dereferencing, and in the main after returning from f3) will be the
same - all three printfs will be printing the value of the x which is located in the memory area
belonging to the main function. Be sure to label each printing of x with a few words so you can tell
them apart on your output. Modify f3 to add 4 to x ensuring that in the main function you are
printing out the value of x both before and after the call to f3. Drop the print inside f3. Again note

2. that x is in the main function (it's a word - at some location - in the memory area associated only
with the main function). You want to change the value of x, but you need to do that work in the
function f3. f3 has its own memory area, but it can't directly use the variables in the main function's
memory area (where x lives). BUT, in f3 you DO have the address of where x is located in the
main function's memory area. To emphasize, x is in the main function, x_address is in function f3.
You have that address of x inside f3 because it was copied ("passed") into x_address when in the
call to f3 you passed &x as an argument. So to access x (either to get it or to set it) in f3 you have
to dereference the x_address. Again, by dereferencing the x_address in the f3 code, you are
working (in f3) with the memory word x which is only in the main function. Important aside: It is
important to recognize that using addresses (pointers) is not directly dependent on whether or not
you are using functions. If you had both x and x_address declared in a main function and were to
put the address of x into the variable x_address in the main function code with the statement
x_address = &x; , then the following two lines are absolutely equivalent in the main function and
you could use either: x = x + 4; and *x_address = *x_address + 4; Why do we go through all this
rigamarole with addresses when we want to change a value in a function? Because in C (and
many other computer languages) argument values are only ever **passed into** (copied into)
function parameters. Nothing (!!) is EVER "passed back". So if you just copied in x to y, as in the
earlier steps of this lab, you could change y all you wanted in the function... and x in the main
function would still be the same old x it always was. You would only be changing the COPY of x in
f3 (y would be the copy as you used it in the earlier steps 6 or 7). So, if we want a change to be
made to a value in the main function, we pass the address of WHERE we want the change made
(in the main function) to the helper function (such as f3); the helper function accesses that
address/location in the main function's memory, which it does have [of course it does, we passed
that address to the function] and the called function (f3) makes the change there (in the calling
main function). Note also that using a return statement to bring something "back" is a completely
separate issue, and it can only return a single value - whereas in a great many cases far more
than one item from a function is wanted. In those cases, such as you did in this step and will also
do in the step below, you have to pass an address and then use dereferencing in the called
function. Now that you've seen how to pass in an address of a variable to a function and in that
function use that address to make a change to the variable, back in the calling (main in this case)
function, you can comment all the preceding function calling and write and call another void
function f4 which has three parameters. The first, an integer variable named y, will be passed the
initial number x from the main function, as seen above. The other two parameters will receive
addresses from the call. The second parameter, named addr1, will be used to receive the address
of a variable named num_of_tens which you will declare in the main function. The third parameter,
named addr2, will be used to receive the address of a variable named remainder also declared in
the main function . In the main function, the value will first be set for x, as above, and then f4 is to
be called, passing it the value of x and the value of the address of num_of_tens (written as
&num_of_tens) and the value of the address of remainder (written as &remainder). Neither
num_of_tens or remainder have had anything put into them at the point where f4 is called. In fact,
nothing in the main function will set them. f4 will, using the code you wrote earlier, determine the
number of 10s in y (copied from x) and the remainder when y is divided by 10. By dereferencing

3. addr1 and addr2, f4 will then set these calculated values into the variables num_of_tens and
remainder (they are both in the main function's memory area or as we often term in "they are in
the main function") ... and then f4 will quit. Nothing is returned, nothing is "sent back". You passed
in two addresses, made changes at those two addresses, and then the function is finished and
control passes back to the main function. Immediately after the call to f4, in the main function write
code so that it will print out the values of num_of_tens and remainder, properly labeled. Try this
with a few different initial numbers. You final program should look like this. The user enters a
number between 10 and 99 (validated), then the program calls the function f3 that gives both the
quotient and the remainder of a division by 10. The two values are printed out (not in the f3
function, but in the main program).