Lab 6 -- Introduction To Pointers

CPE101

Winter 2008

 

Updates and Corrections

 

 

Due Date:

 

By the end of your last lab of week 6.

 

Objectives

 

 

Overview

 

In this lab you will be exploring the concept of a pointer.  When you declare a variable, space is set aside for it in memory (where in memory is outside the scope of this class).  Each memory location in the computer has an address.  You can think of that address like a mailbox number.  Thus far in this class we have referred to variables only by their names.  However, we can also refer to variables by their address.  A pointer is simply a variable that holds the address of another variable.  In essence, the pointer variable "points" to where the second variable is located in memory.

 

Why in the world would we want a variable that points to the location of another variable?  Excellent question.  In this lab we will explore the concepts of variables having an address, of a variable pointing to another variable, and finally why we would need to use a pointer in the first place.

 

The first part of this lab will be a step-by-step exploration of the concepts necessary to understand pointers.  I ask that you do not read ahead, but instead complete the tasks asked of you as we go.  The second part of the lab will contain programming tasks for you to complete and hand in.

 

 

Pointer Exploration

 

What's an address?

Let's begin with a sample program to explore the concept of a variable being stored in a particular memory location.  When you refer to a variable by its name you get the value of the variable.  For example, the following code prints the value of a variable called x:


printf("%d", x);


However, if you want to know the address of a variable, you put the '&' (ampersand) symbol in front of it.  The following code prints the address of a variable called x:


printf("%d", &x);


Now consider the following code:


#include <stdio.h>

int main(void)
{
   int x, y;
   double z;

   x = 5;
   y = -69;
   z = 1.0;

   printf("x is %d.  The address of x is %u.\n", x, &x);
   printf("y is %d.  The address of y is %u.\n", y, &y);
   printf("z is %f.  The address of z is %u.\n", z, &z);

   return 0;
}


The code declares 3 variables.  It then prints the value and the address of each variable.  Compile this code using gcc, but without all the usual flags.


gcc addresses.c


What were the addresses of the variables?  Which variable had the smallest address?  How many bytes does the variable z take up?  How many bytes does the variable y take up?


What's a pointer?


Now let's declare and use our first pointer.  To declare a pointer you put an asterisk '*' in front of the name of the variable.  The following code declares a pointer to an integer:


int *x;


This variable is now set up to hold the address of some other integer.  Copy, compile, and run the following code:


#include <stdio.h>

int main(void)
{
   int x;
   int *px;

   x = 5;
   px = &x;  /* set px to the address of x */

   printf("x is %d.  The address of x is %u.\n", x, &x);
   printf("px is %u.  The address of px is %u.\n", px, &px);

   return 0;
}

 
Notice that the value of px (the pointer) is the same as the address of x.  In essence, px knows where x is stored in memory.  Notice that px has an address, too.  It is a variable stored in memory just like any other variable.


Now you should be asking yourself, so what?  Can I do anything with this pointer?  We can use px to get the value of x, even though px only stores the address of x.  (It's similar to being able to go get someone's mail if you know their address.)  We can get the value of x by "dereferencing" px.  When you dereference a pointer, you are telling the machine to go to the address the pointer is pointing at and get that value out.  So, if px is pointing at x, we get the value of x when we dereference px.


Let's look at an example.  To dereference a pointer we put an asterisk in front of it.  (Note that this is completely different from using an asterisk to declare a pointer.)  Add the following printf statement to the code above:


printf("Value of *px is %d.\n", *px);


Now compile and run the code.  The value of *px (px dereferenced) is the same as x. 


We can modify x the same way, if we dereference px and set it to something, we change x.  Add this code to your file:


*px = 6;
printf("x is now %d\n", x);


We are telling the computer to go to where px is pointing and change it to 6.  Compile and run the code to make sure it works as advertised.


The big deal...


We are finally ready to see an example of how this is useful.  Consider the following main and swap functions.  The swap function takes two integers as parameters and is supposed to swap their values.  Do not compile and run the code yet.


#include <stdio.h>
void swap(int a, int b);

swap1.bmp

int main(void)
{
   int x, y;

   x = 5;
   y = 10;

   swap(x,y);

   printf("x = %d, y = %d\n", x, y);


   return 0;
}
void swap(int a, int b)
{
   int temp;
  
   temp = a;
   a = b;
   b = temp;
} 


What do you think will be printed to the screen?  What will the values of x and y be?  Now compile and run the code.  Why didn't x and y get swapped?  The reason is that we passed the values of x and y to a and b.  We initialized a with the value of x and b with the value of y.  Then we swapped a and b.  The variables x and y never got touched.  The swap() function has no way to access x and y.


The following code modifies the swap function so we pass the addresses of x and y.  That way the swap function knows where in memory x and y are located.  Since swap knows where they are, it can change them.  Copy, compile, and run the following code:


#include <stdio.h>
void swap(int *a, int *b);

int main(void)
{
   int x, y;

   x = 5;
   y = 10;

   swap(&x,&y); /* pass the addresses of x and y */

   printf("x = %d, y = %d\n", x, y);

   return 0;
}
void swap(int *a, int *b)
{
   int temp;
  
   temp = *a;  /* set temp to the value a is pointing at */

   *a = *b;    /* go to where a is pointing and give it
                * the value of what b is pointing at */

   *b = temp;  /* go to where b is pointing and set it to temp */
} 


Notice in main that we pass the addresses of x and y, instead of their values.  Now a holds the address of x and b holds the address of y.  First we set temp equal to the value a is pointing at (5).  Then we set the value of where a is pointing (x) equal to the value of what b is pointing at (10).  Finally, we set the value of where b is pointing to the value of temp (5).


The big point of all this is that by knowing the addresses of x and y, swap() was able to modify those variables.  It had no direct knowledge of x and y, but only knew where in memory they were located.  Until know, we've only been able to pass the values of variables to functions and get a single return value.  Now we can actually modify variables inside of functions.


You should now be able to answer the question, "Why do we use '&' with scanf and not with printf???"  Printf only needs the value of whatever variable you want print.  Scanf needs to modify the variable you pass to it.  It scans something in from the keyboard and then stores it in memory to the address of the variable you pass to it.  A function can not modify a variable if you only pass its value.


Output Parameters


A function paramter that is a pointer can be referred to as an output parameter.  The function is relaying information to you via that parameter.  Consider a function that has two parameters.  The first is an integer test score.  The second is a pointer to a char that the function will fill in with a letter grade based on the test score.  The return value of the function will be an integer: 0 if the test score was valid (0-100) or -1 if the test score was invalid.  The function prototype might look like this:


    int letterGrade(int score, char *grade);


The first parameter, score, is an input parameter.  It is information the function needs to do its job.  The second parameter, grade, is an output paramter.  The function fills it in with information that we need.


Can I declare a pointer to any kind of variable?


Yes.  You can have a pointer to an int, double, char, another pointer, or even structures (we'll cover these soon).  Passing a variable's address to a function allows the function to modify the variable.  However, there is another reason we might want to pass a variable's address instead of its value.  Consider the following structure:


typedef struct
{
   char make[20];
   char model[20];
   int numDoors;
   double mpg;
} Car;


How much space in memory does every variable of type Car take up?  Can you guess?  Here is a simple program to find out.  It uses the sizeof() operator.  Although it looks like a function call, sizeof() is an operator just like = or +.  To use it, simply put the thing you want to know the size of in the parentheses.  It will evaluate to the number of bytes in the thing you're asking about.  You may put a variable or a type in the parentheses.  Copy, compile, and run the following code:


typedef struct
{
   char make[20];
   char model[20];
   int numDoors;
   double mpg;
} Car;

int main(void)
{
   Car car;

   printf("Number of bytes in Car: %d\n", sizeof(car));

   return 0;
}


Did you guess correctly?  When we pass a Car to a function all this information must be copied to the function parameter.  If a structure is 100 bytes, then 100 bytes of information get passed to the function.  Where these bytes get put is outside the scope of this class.  However, we want you to know that it is sometimes undesirable to pass that much information in a function call.  A pointer only takes up 4 bytes.  So, if we pass a pointer to a Car, we only take up 4 bytes in memory, but still have access to all the information about the structure.


Here is code that passes the value of a structure to a function:


/* structure definition not shown */
void printCar(Car c);

int main(void)
{
   Car car = {"Volvo", "V70", 5, 24.0};

   printCar(car);

   return 0;
}

void printCar(Car c)
{
   printf("Size of 'c': %d\n", sizeof(c));
   printf("Make: %s\n", c.make);
   printf("Model: %s\n", c.model);
   printf("Doors: %d\n", c.numDoors);
   printf("MPG: %.2f\n", c.mpg);
}


Copy, compile, and run the code.  Notice the size of c is 52 bytes.  Now let's modify the code to work with a pointer to a Car.  First you need to know that we cannot use the '.' operator with a pointer to a structure.  A pointer to a Car doesn't have a model or make.  It is simply an address.  So, we need to dereference the pointer before we can access those attributes.  Assume we have a pointer to a Car called 'c'.  We could dereference it by writing (*c).make.  But, that is ugly and cumbersome, not to mention it's hard to remember where the parentheses go.  So, we can instead us the -> operator.  To dereference a pointer to a structure and access one of its fields we can type c->make.  Here is the code modified to work with pointers:


/* structure definition not shown */

void printCar(Car *c);

int main(void)
{
   Car car = {"Volvo", "V70", 5, 24.0};

   printCar(&car);

   return 0;
}

void printCar(Car *c)
{
   printf("Size of 'c': %d\n", sizeof(c));
   printf("Make: %s\n", c->make);
   printf("Model: %s\n", c->model);
   printf("Doors: %d\n", c->numDoors);
   printf("MPG: %.2f\n", c->mpg);
}


Copy, compile, and run this code.  This time, how big was the variable c?  We saved a lot of memory by passing the address of the structure instead of the entire structure.  Furthermore, we could now modify the car structure inside the function.

 

Lab Requirements (Or the answer to "So what am I supposed to hand in?")

  1. In a file called part1.c, create a function to do integer division that gives the division result and remainder via output parameters.  Additionally, the function should return an int representing the success/failure of the function.  The function should return 0 if it succeeds and -1 if there is a divide by zero error.  (Note that you should not actually do the division if there will be a divide by zero error.  Simply return -1.)  Use the following prototype:

int intDivide(int x, int y, int *quoPtr, int *remPtr);

Create a main with integer variables called dividend, divisor, quotient, and remainder.  You may create additional variables if you wish.  Query the user for the dividend and divisor.  Call your function and print the results, including and error message if there is a divide by zero.
  1. In a file called part2.c, define a function sumAndAvg that takes three doubles as input parameters, computes the sum and average of the numbers, and then relays both results via output paramters.  Create a main to test your function.
  1. Use the structure below to complete this part of the assignment.  In a file called part3.c, create a function to initialize a Pet with input values queried from the program user.  The function should have a pointer to a Pet as its only parameter.  It should return void.  Write a main to declare a Pet.  Call your function to initialize the Pet.  Finally print all the information about the Pet to the screen.
typedef struct
{
   int age;
   double weight;
   char name[20];
   int numLegs;
} Pet;


Handing in Your Source Electronically . . .

  1. If necessary, move your source (part1.c, part2.c, and part3.c) to vogon.

 

  1. Log on to vogon via some terminal somewhere.

 

  1. Change directory (cd), as necessary, to the directory where your source file(s) are.

 

  1. Compile and test your source on vogon using the required compiler flags (-Wall --ansi --pedantic)

 

  1. Use the handin command being sure to replace the yy with your lecture section number.

 

11:59 vogon ~$ handin mhaungs Lab06-yy part1.c part2.c part3.c



Extra Challenges (What do I do if I finish the lab but want more practice?)


Create a function called makeChange that takes an integer price of a product (in pennies) and an integer amount of money paid (in pennies).  It should return via output paramters the number of dollars, quarters, dimes, nickles, and pennies given as change.  The function should always give the highest denomination of money when available.  For example if the change is $1.34.  The change should be 1 dollar, 1 quarter, 1 nickel, and 4 pennies.  Create a main to test your function.