Lecture #8: Pointers

Computer Programming (8) - Pointers

administrivia

Web Page - http://www.cs.tau.ac.il/~efif/courses/ComputerProgramming

the nature of memory

way back, we talked about computer memory
- it’s a bunch of bytes
- each byte can hold 256 values
- "adjacent" bytes can be combined to hold larger values
  - usually grouped in powers of 2 (2, 4, 8, 16, …)
What’s "adjacent" mean?
- bytes in memory are numbered sequentially

sequential numbering

so memory is a long sequence of storage spaces for numbers
- like a long line of lockers
- each locker is given a number
- C lets us use that number…

addresses

in C, we call these "locker numbers" addresses
- an address is the number of the byte we want
  - or if we’re talking about a grouped byte, it’s the first byte of the group
when a variable contains an address, we call it a pointer
- because it "points" to some other data in memory

it’s like a treasure hunt…

up to now, we’ve dealt only with straightforward variables
- they hold the data we care about
- just like a locker holding something for me
  - I can put my book in my locker and get it again later
pointers introduce a level of indirection
- instead of holding the data, they hold information about where to find the data
- so now my locker would only hold a piece of paper, telling me which locker to look in for my book

what’s the point?

indirection can be helpful
- when the actual data location may change
analogy: the customer_support@some_company.com e-mail address
- mail sent to this address goes to me
- but next term, if someone else is working in customer support, it will go to that person

just more numbers

like every other kind of data we use, addresses are numbers
- up to now, though, our data has been numbers we care about
  - temperatures
  - dates
  - results of calculations
- addresses are numbers too, but ones that only are useful to the program while it’s running

data types

a pointer isn’t a new data type
- it’s just kind of a modification, because the pointer should point to a data type
  - or another pointer, that must eventually find a data type

declaring a pointer

we declare a pointer using a *
- this declaration creates a variable named ptr
  int * ptr;
  - ptr is a variable whose value is an address
  - the thing we expect to find at that address is an int
  - since an int is 4 bytes (on our computers, at least), this is the address of the first byte of a group of 4 bytes
- but ptr has not yet had its value set, so it does not yet contain a valid address of anything

the address-of (&) operator

the unary operator & is used to find an object’s address
- that is, its operand is an object
  - remember that an object is something with memory associated with it
- the value of the expression (operator and operand) is the address in memory of the operand

example

so, let’s put this all together:
int i = 1; int *ptr = &i;
- the first line defines a variable named i
  - it is an int, and thus has 4 bytes of memory reserved for it
  - its value is set to 1

example

so, let’s put this all together:
int i = 1; int *ptr = &i;
- the second line defines a variable named ptr
  - it is a pointer to an int
  - it is initialized to the address of i
    - thus, it contains a number which is an address
    - if you look at the 4 bytes starting at that address, you will find the value 1

the contents-of (*) operator

the unary operator * is used to access whatever is at a given address
- its operand is an address
- the value of the expression is an lvalue
  - remember that an lvalue is an expression that refers to an object
  - and an object is something with memory associated with it
  - an address is supposed to refer to a location in memory
  - so an expression using the * operator refers to an object, and thus is an lvalue
- that means we can assign its value as well as look at it

example

what does this print?

int i = 1;
int *ptr = &i;
    
*ptr = 2;
printf ("%d\n", i);

example

what does this print?
int i = 1; int *ptr = &i; *ptr = 2; printf ("%d\n", i);
- i is an int, containing the value 1
- ptr is a pointer, containing the address of i

example

what does this print?
int i = 1; int *ptr = &i; *ptr = 2; printf ("%d\n", i);
- *ptr refers to the thing that ptr points to
- ptr points to the memory that stores the value of i
- so this line assigns the value 2 to i

example

int i = 1;
int *ptr = &i;

*ptr = 2;
printf ("%d\n", i);

what does this print?
- it just prints the value of i
- which is now 2

confusion

this is going to be confusing for a while
we have 2 values now:
- the value of the pointer
  - which determines what the pointer points to
- and the value in the location the pointer points to

confusion

we can change the value of the pointer:

example

int i = 42;
int j = 17;
int *ptr = &i;

*ptr = 1;
ptr = &j;
*ptr = 2;

What does this do?

example

what does this do?
- this declaration creates the variable i
  - i is an int, containing the value 42

example

what does this do?
- this declaration creates the variable j
  - j is an int, containing the value 17

example

what does this do?
- this declaration creates the variable ptr
  - ptr is pointer
  - initially, it points to i

example

what does this do?
- this statement assigns the value 1 to whatever ptr points to
  - which, as we already know, is i

example

what does this do?
- this statement reassigns the value of ptr
  - so it now points to j instead of i

example

what does this do?
- and finally, we assign the value 2 to whatever ptr points to
  - which is now j

operations on pointers

what we’ve seen so far:
- assignment (=)
- dereferencing (*)
- address (&)

pointer assignment

as with arithmetic assignment:
- the object on the left side must be an lvalue
- therefore, this is not valid:
  &j = &i
both operands must be pointers to the same data type
- valid:
  int i; int *ptr = &i;
- invalid
  double d; int *ptr = &d;

pointer dereferencing

single operand, must be a pointer
the data type of the expression is the data type of whatever the pointer points to
- thus, given this declaration,
  int * ptr;
- the data type of the expression *ptr is int

address-of operator (&)

operand must be something with memory associated
- so the expression &(i+j) is invalid
the data type of the expression is "pointer to T"
- where T is whatever the data type of the operand is

remember…

pointers give us a way of referring directly to a location in memory
we can declare a pointer variable:
- but it doesn’t actually "point" to anything until we set its value to a real address
we can find the address of a variable
- using the & operator
  int i; int *p = &i;

remember…

we can operate on what a pointer points to
- using the * operator
  int i; int *p = &i; *p = 3;
- this sets the value of i to 3

NULL

there is a special value for pointers, named NULL
- this is the canonical "invalid" value
  - it’s never a valid address
  - it can be used to indicate when a pointer variable is not set to an address
  - it’s useful for initializing pointer variables before you’ve actually set their value
  - it’s used in a lot of other situations too, we’ll encounter some
- don’t confuse this with the nul character, which is the name for ASCII code 0
  - also ‘\0’

pointers and function arguments

when I introduced functions, I said that functions can have any number of inputs (arguments), and a single output (return value)
- I lied. Well, sort of…

how did I lie?

in C, arguments are passed by value
- this means that when you specify an expression as an argument to a function call, the value of that expression is copied into the parameter in the function
  - remember, a variable name is a simple expression
- so when we change the value of a function parameter, we’re changing a copy, and the change doesn’t affect the variable used to call the function

example

changes to parameters don’t "pass back"

#include 

#define MAX 10

int square(int x)
{
  return x * x;
}

int main(void)
{
  int i;
  for (i = 0; i < MAX; ++i) {
    int isquared = square(i);
    printf ("%d squared is %d\n", i, isquared);
  }
  return 0;
}

but…

what if the variable we pass into a function is a pointer?
- we still can’t change the parameter inside the function and expect the change to affect anything outside the function
- but we can change the thing the pointer points to
  - and then when we return from the function, we can find the change at the same location

example

#include 

#define MAX 10

int swap(int * a, int * b)
{
  int tmp;
  tmp = *a;
  *a = *b;
  *b = tmp;
}

int main(void)
{
  int i = 3, j = 5;
  swap(&i, &j);
  printf ("%d %d\n", i, j);
  return 0;
}

example – what’s going on here?

#include 

#define MAX 10

int swap(int * a, int * b)
{
  int tmp;
  tmp = *a;
  *a = *b;
  *b = tmp;
}

int main(void)
{
  int i = 3, j = 5;
  swap(&i, &j);
  printf ("%d %d\n", i, j);
}

example – what’s going on here?

#include 

#define MAX 10

int swap(int * a, int * b)
{
  int tmp;
  tmp = *a;
  *a = *b;
  *b = tmp;
}

int main(void)
{
  int i = 3, j = 5;
  swap(&i, &j);
  printf ("%d %d\n", i, j);
  return 0;
}

example – what’s going on here?

#include 

#define MAX 10

int swap(int * a, int * b)
{
  int tmp;
  tmp = *a;
  *a = *b;
  *b = tmp;
}

int main(void)
{
  int i = 3, j = 5;
  swap(&i, &j);
  printf ("%d %d\n", i, j);
  return 0;
}

example – what’s going on here?

#include 

#define MAX 10

int swap(int * a, int * b)
{
  int tmp;
  tmp = *a;
  *a = *b;
  *b = tmp;
}

int main(void)
{
  int i = 3, j = 5;
  swap(&i, &j);
  printf ("%d %d\n", i, j);
  return 0;
}

example – what’s going on here?

#include 

#define MAX 10

int swap(int * a, int * b)
{
  int tmp;
  tmp = *a;
  *a = *b;
  *b = tmp;
}

int main(void)
{
  int i = 3, j = 5;
  swap(&i, &j);
  printf ("%d %d\n", i, j);
  return 0;
}

example – what’s going on here?

#include 

#define MAX 10

int swap(int * a, int * b)
{
  int tmp;
  tmp = *a;
  *a = *b;
  *b = tmp;
}

int main(void)
{
  int i = 3, j = 5;
  swap(&i, &j);
  printf ("%d %d\n", i, j);
  return 0;
}

example – what’s going on here?

#include 

#define MAX 10

int swap(int * a, int * b)
{
  int tmp;
  tmp = *a;
  *a = *b;
  *b = tmp;
}

int main(void)
{
  int i = 3, j = 5;
  swap(&i, &j);
  printf ("%d %d\n", i, j);
  return 0;
}

example – what’s going on here?

#include 

#define MAX 10

int swap(int * a, int * b)
{
  int tmp;
  tmp = *a;
  *a = *b;
  *b = tmp;
}

int main(void)
{
  int i = 3, j = 5;
  swap(&i, &j);
  printf ("%d %d\n", i, j);
  return 0;
}

so what does all that mean?

you can "return" more values from a function than just the return value
- by passing in pointers to other variables
- the function can then use the pointer to change the value of the variable

scope

this circumvents the "scope" rules we talked about earlier
- remember that a variable’s scope determines where it can be seen from within the program
- so in our example, i and j were not in the scope of the function swap(), but we changed their values anyway

extent

there is another variable concept called extent, that we haven’t really talked about
extent determines how long the variable exists while the program is running
- scope is a static property: it applies to the code
- extent is a dynamic property: it applies to the running program
extent and scope are often mixed together, but they’re really separate concepts

extent

let’s look at our swap function again

void swap (int *a, int *b)
{
  int tmp;
  tmp = *a;
  *a = *b;
  *b = tmp;
}

notice that the variable tmp is declared at the beginning of this function
- thus, its scope is the entire body of the function
- and the scope rules say that we can only use the name tmp within the function

scope vs. extent

but we just saw an example where we manipulated variable values from outside their scope
- so in that case, the variables still existed somewhere in memory
- scope says whether we can use the name, not whether the variable will exist or not

variable lifetime

but each variable has a well-defined lifetime
- at some point, the computer sets aside the memory for that variable
  - before that point, the variable doesn’t exist
- at some later point, the compter frees the memory for that variable, so it can be used for something else
  - after that point, the variable doesn’t exist either
  - and if we still have a pointer to that memory, it’s no longer valid
  - to use that locker analogy, it would be like someone still having a slip of paper with my locker number on it, even though I’ve graduated and my locker’s been given to someone else

variable extent

the lifetime of the variable is its extent
- most of the variables we’ve seen and used so far have automatic extent
that means they’re created and destroyed automatically, as needed
each type of scope has its own extent rules
and we can manually affect the extent of some variables

swap() again

void swap (int *a, int *b)
{
  int tmp;
  tmp = *a;
  *a = *b;
  *b = tmp;
}

In swap(), we declare the variable tmp
- and it’s a definition: it reserves some memory
- but up to now, we haven’t looked at when that memory is reserved, and when it’s released.

extent of tmp

the extent of tmp in this case pretty much mirrors its scope
- it’s created when we enter the function
- it’s destroyed when we leave the function
- that means that every time we call the function, the expression &tmp may have a different value

extent of i and j

similarly i and j exist from the beginning of the block in which they’re declared until we leave it
- which is really from the beginning of the program until it ends
- so they exist while swap() is being called

so what?

why do we care about extent?

what if we did something like this?

/*
 * power: calculate m to the nth power
 */
long *power (int m, int n)
{
  int i;
  int product = 1;

  for (i = 1; i <= n; ++i)
    product *= m;
  return &product;
}

returning a pointer

/*
 * power: calculate m to the nth power
 */
long *power (int m, int n)
{
  int i;
  int product = 1;

  for (i = 1; i <= n; ++i)
    product *= m;
  return &product;
}

now we’re returning a pointer
- (don’t ask why; this is a contrived example)
- but product’s extent ends at the return statement
- so this function always returns an invalid pointer

Maintained by Efi Fogel. Last modified: January 25 2003.