CS 240 Lab 6

Extra Pointers Exercises

CS 240 Lab 6 Extras

• Lab slides
• Main notebook
• Learning Goals & Reflection

This notebook contains some extra exercises if you want more practice with pointers and pointer programming.

Extra Exercises: More Pointers Practice

If you want more practice understanding pointers, pointer math, and related types, deducing the values of various expressions in the table below.

You’ll be filling in values based on this code:

int *start = (int*) 0xa0000;
int *end = (int*) 0xa0010;
char *startStr = (char*) start;
char *endStr = (char*) end;
// Line 1
startStr[0] = 2;
startStr[1] = 1;
startStr[2] = 0;
startStr[3] = 0;
// Line 2
startStr[2] = 1;
*start = 515;
// Line 3

For each line in the table below, give the type and value of the result of the listed expression. Each expression should be evaluated as if it were run at a specific point in the code, identified by one of the ‘Line’ comments. The first line has been filled in as an example.

• All of your answers in column 3 should be numbers. Write addresses in hexadecimal with a leading 0x to indicate their base, and write integer and character values in decimal.
• Assume that you are using a machine with 32-bit integers and 64-bit addresses using little-endian byte ordering.
• The sizeof function returns the number of bytes taken up by one value of the specified type. If given a variable, it measures the size of that variable’s type.
• The type for any sizeof result should be size_t, and the type for any result which is a difference between two addresses should be ptrdiff_t.
• Remember that when adding to or subtracting from a pointer to do address arithmetic, the integer added or subtracted will automatically be multiplied by the size (in bytes) of the kind of value that the pointer points to. Similarly, when subtracting two addresses their difference in bytes will be divided by their stride, to give an answer in “array units” rather than bytes.
• Remember that x[y] is equivalent to *(x + y).

Exercise 1:

Evaluate these expressions as if they were run where it says “Line 1:”. The first few have been filled in already.

These expressions should be evaluated as if the code was at “Line 2,” where the items in the startStr array have been set to new values:

These expressions should be evaluated as if the code was at “Line 3,” after *start has been updated.

Extra Exercises: More Pointer Programming

Exercise 2:

In the main notebook you created an arrayOps.c file. In that file, implement a function called unzip and another called freeUnzipped. unzip should take an array and its length, and should allocate and return a 2-item array of int* pointers, each of which will point to a newly-allocated array of integers. The first array of the pair will hold all the even-index entries from the given array, while the second entry of the pair will hold odd-index entries. Make sure to use malloc with appropriate sizes.

freeUnzipped will be given an array-of-two-arrays in the style that unzip produces and will free both sub-arrays and then free the main pair array, so that everything gets cleaned up. If one or both of the sub-arrays is NULL for some reason, freeUnzipped should not attempt to free it.

Use test-driven development (there are a number of interesting edge cases you’ll need to decide how to handle).

You can compare your solution and tests against those in arrayOpsSolution.c. Of course our tests may not be valid if you made different design choices.

Exercise 3:

In arrayOps.c, use test-driven development to implement longestRun It should take three parameters: an array of integers, its length, and a pointer to a length-result variable to update. It will find the longest run of integers in the array and return an array containing those integers, setting the length-return variable to the length of the run.

You can compare to the solution in arrayOpsSolution.c, although again, there are lots of design decisions to make (e.g., what counts as a run? Are we allocating a new array or returning a pointer to somewhere inside the array we’re given? What happens with the length-result variable when the input is invalid? etc.).

Extra Exercises: More Predictions

For practice reading code that uses pointers and a look at some surprising things that can happen, look at the files main9.c, mystery0.c, and mystery1.c: open each file, read the C program, predict the printed output, then compile and run the program to verify your predictions. Explain any surprising behavior in the actual output.

Exercise 4:

Predict the output of main9.bin:

Was there anything surprising about the output of main9?

Example answer: The fact that the numbers are little-endian and so you don’t get the alphabet in order is probably surprising…

Predict the output of mystery0.bin:

a = "hello!"
b = "hello!"
a = "cs 240"
b = "hello!"
a = "cs0xF"
b = "hello!"

Was there anything surprising about the output of mystery0.bin?

Example answer: The behavior of the final block is a bit tricky. Since the mystery function (which copies strings) writes a NUL byte at the end, the “cs 240” string is effectively shortened.

Predict the output for mystery1.bin:

x = 19
p = <some stack address starting with 0x7ff…>
a = "Hello!"
b = "Hi!"

x = 19
p = <same stack address as before>
a = "CS 240!"
b = "Hi, CS 240!"

x = 1634038304
p = 0x7520657720666920
a = " happens if we use a really really long string?"
b = "What happens if we use a really really long string?"

Surprises in actual output for mystery1:

Extra Exercises: More Pointer Code

Exercise 5:

If you want extra practice, the practiceSolutions.c file contains solutions for the functions in practice.c, which already have documentation and tests set up.

You can compile and run the file with:

make practice.bin
./practice.bin

You may wish to add | less to the second command to paginate the output. If you do, use ‘q’ to quit pagination when you’re done.