LECTURE 14: Pointers (Reference: “Pointers and Memory” handouts, available from the course web page)

Definition: Pointer is a variable that stores an address of another variable

Therefore, pointer is just another variable type!!

The statement:

int num;

declares integer variable num and reserves space in memory to store its value. Computer also records the address of the reserved memory location.

num:

address of num

value of num

The statement:

int *nump;

declares nump, a pointer to integer, and reserves space in memory to store its value. The value of nump is address of an integer variable to which nump points to. Computer also records the address of the memory location that stores value of nump.

nump:

address of nump

value of nump

Example 1:

int num; // value of num is some junk value

int *nump; // nump is pointer

// value of nump is some junk address

nump = # // value of nump is address of num variable

*nump = 42; // value of variable where nump points to becomes 42

// because nump points to num, value of num becomes 42!!

Example 2:

int a = 1; // a is declared as integer and its value is set to 1

int b = 2, c = 3;

int *p, *q; // p and q are declared as pointers to integers and

// their values are some junk addresses

p = &a; // value of p is is address of a

q = &b; // value of q is address of b

c = *p; // value of c is the value of variable to which p points to

// since p points to a, c = 1

p = q; // value of p equals to value of q, which is address of b

// so, p becomes pointer to b too

*p = 13; // 13 is assigned to variable pointed to by p, which is b

// so, b = 13

Example 3:

int *p; // pointer to integer p is created, its value is some junk address

*p = 42; // value 42 is saved at the junk address pointed to by b

// this is very dangerous mistake since the junk address can

// hold some very important data which will be corrupted by this

Functions with Simple Outputs (Section 6.1 from the textbook)

Motivation: using the return command a function can return only a single number; using pointers it will become possible for a function with more than one output.

Example:

Consider function called separate whose input is a number of type double (e.g. 4.35), and whose output is sign (e.g. +), whole part (e.g. 4), and fractional part (e.g. 0.35).

Solution: Figure 6.3 (Program That Calls a Function with Output Arguments)

/*

* Demonstrates the use of a function with input and output parameters.

*/

#include <stdio.h>

#include <math.h>

void separate(double num, char *signp, int *wholep, double *fracp);

int

main(void)

{

double value; /* input - number to analyze */

char sn; /* output - sign of value */

int whl; /* output - whole number magnitude of value */

double fr; /* output - fractional part of value */

/* Gets data */

printf("Enter a value to analyze> ");

scanf("%lf", &value);

/* Separates data value into three parts */

separate(value, &sn, &whl, &fr);

/* Prints results */

printf("Parts of %.4f\n sign: %c\n", value, sn);

printf(" whole number magnitude: %d\n", whl);

printf(" fractional part: %.4f\n", fr);

return (0);

}

/*

* Separates a number into three parts: a sign (+, -, or blank),

* a whole number magnitude, and a fractional part.

* Pre: num is defined; signp, wholep, and fracp contain addresses of memory

* cells where results are to be stored

* Post: function results are stored in cells pointed to by signp wholep, and

* fracp

*/

void

separate(double num, /* input - value to be split */

char *signp, /* output - sign of num */

int *wholep, /* output - whole number magnitude of num */

double *fracp) /* output - fractional part of num */

{

double magnitude; /* local variable - magnitude of num */

/* Determines sign of num */

if (num < 0)

*signp = '-';

else if (num == 0)

*signp = ' ';

else

*signp = '+';

/* Finds magnitude of num and separates it into whole and fractional parts */

magnitude = fabs(num);

*wholep = floor(magnitude);

*fracp = magnitude - *wholep;

}

Example of program execution:

Enter a value to analyze> 35.817

Parts of 35.8170

sign: +

whole number magnitude: 35

fractional part: 0.8170

Explanation of the program:

- the main function informs separate function of the value of variable value, and addresses of variables sn, whl, and fr.

- the separate function creates memory space to store num variable (of type double), and pointers signp, wholep, and fracp.

- value of num will equal the value of value; value of signp will equal the address of sn, value of wholep will equal the address of whl, and value of fracp will equal the address of fr.

- use of pointers in separate function allows it a direct access to variables sn, whl, and fr. This means that separate can directly read and modify their values. For example,

*signp = ‘-‘;

directly assigns value of ‘-‘ to sn from the main function.

- the following figure illustrates the connection between variables in main and separate functions:

Use of a Single Parameter as Both Input and Output (Section 6.2)

By use of pointers it is also possible to use the same parameter as both input and output of a function.

Example:

The goal is to ask user to enter 3 numbers and order them in the ascending order. Function order should be used. It swaps the values of two numbers if the first number is larger than the second.

Solution: Figure 6.6, Program to Sort Three Numbers

/*

* Tests function order by ordering three numbers

*/

#include <stdio.h>

void order(double *smp, double *lgp);

int

main(void)

{

double num1, num2, num3; /* three numbers to put in order */

/* Gets test data */

printf("Enter three numbers separated by blanks> ");

scanf("%lf%lf%lf", &num1, &num2, &num3);

/* Orders the three numbers */

order(&num1, &num2);

order(&num1, &num3);

order(&num2, &num3);

/* Displays results */

printf("The numbers in ascending order are: %.2f %.2f %.2f\n", num1, num2, num3);

return (0);

}

/*

* Arranges arguments in ascending order.

* Pre: smp and lgp are addresses of defined type double variables

* Post: variable pointed to by smp contains the smaller of the type

* double values; variable pointed to by lgp contains the larger

*/

void

order(double *smp, double *lgp) /* input/output */

{

double temp; /* temporary variable to hold one number during swap */

/* Compares values pointed to by smp and lgp and switches if necessary */

if (*smp > *lgp) {

temp = *smp;

*smp = *lgp;

*lgp = temp;

}

}

Example of program execution:

Enter three numbers separated by blanks> 7.5 9.6 5.5

The numbers in ascending order are: 5.50 7.50 9.60

Explanation of the program:

- in the main function a user is first asked to enter 3 double numbers

- then, function order is called 3 times. In the first call, the values of num1 and num2 are swapped if num1 > num2. After the three calls to order, the 3 number entered by the user will be sorted in the ascending order

- let us suppose we want to solve the swap problem without using functions. Then, the code would look like this:

if (num1 > num2) {

tmp = num1;

num1 = num2;

num2 = tmp;

}

- why did we use tmp variable?

- order function is given information about the addresses of two variables from main. This gives it opportunity to read and change their values