Lecture 13: Pointers continued

Where we left off

int x = 5;
int *ptr = &x;

*ptr = 10;
cout << "x: " << x << endl;

Today’s topics

• Using pointers
• Pointers and const
• Pointers and structures
• Pointers and arrays

… you get the point

Textbook Chapter 9ish, still

Pointers and const

• const makes a variable read-only

  const int NUM_STUDENTS = 20;
  NUM_STUDENTS = 21; // error! Can't change a const!
  

• What happens with const and pointers?

  int x;
  int y = 37;
  const int *pci = &y; // pointer to a const int
  int * const cpi = &y; // const pointer to an int
  const int * const cpci = &y; // const pointer to a const int
  

Things are getting rather const-y

• A pointer to a constant is a pointer that points to a constant value
  • The value can’t be changed through the pointer
  • The pointer can be changed to point to a different value
  • Whatever it points to becomes read-only
• A constant pointer is like a regular const variable
  • It must be initialized when declared, and can’t be reassigned
  • However, the value at the address it points to can be changed
• A constant pointer to a constant combines the two

The same info in table form

All this gets rather confusing

Pointers and Arrays

• Recall that an array is a contiguous block of memory

• When arrays are declared and space is allocated, the address of the first element is associated with the name of the array, e.g.:

  char A[10]
  strcpy(A, "Hello");
  

  Index	0	1	2	3	4	5	6	7	8	9
  Value	H	e	l	l	o	\0	?	?	?	?

• So… if A is the address of the first element, can we assign it to a pointer?

Pointers and Arrays

char A[10] = "Hello";
char *cptr = A; // no &, because A is already an address

• cptr now points to the first element of A
• What if I modify *cptr?

  *cptr = 'J';
  

• What if I increment cptr?

  cptr++; // add one sizeof(type) to the address
  

Side tangent: Pointer arithmetic

• Array indexing using [] is “syntactic sugar” for pointer arithmetic
• Given the following declaration:

  int arr[10];
  

• These operations are identical:

  arr[0] = 5;
  *arr = 5;
  

• Or, more generally, for an integral index i:

  arr[i] = 5;
  *(arr + i) = 5;
  

Pointers and Structures

• Recall that a structure is a collection of variables that could be different types

  struct Time {
      int hour;
      int minute;
  };
  

• You can access individual fields with . syntax:

  Time t;
  t.hour = 5; // it's 5 o'clock somewhere
  

• And just like anything else, you can declare a pointer to a structure:

  Time *tptr = &t;
  

Pointers and Structures

• To access fields, you first need to dereference the pointer, then use .:

  (*tptr).hour = 5;
  

• This is common enough and annoying enough that there’s a shorthand:

  tptr->hour = 5;
  

• This is called the arrow operator and is only used to access members of a structure or class via a pointer

  tptr->hour++; // now it's 6 o'clock
  cout << tptr->hour << ':' << tptr->min << endl; 
  

Pointer check-in 1/2

Which of the following operators can not be used with pointers?

Pointer check-in 2/2

Which statements are true about the following code snippet? Select all that apply.

int x = 0;
int y = -1;
const int *p = &x;
cout << "x is " << x
     << " and y is " << y << endl;

Pointers and functions

• A pointer variable is like any other variable…
  • It can be passed to a function, by value or by reference
  • It can be returned from a function
• Things get funky passing pointers to functions:

  void foo(int *iptr) {
      int x = 42;
      iptr = &x;
  }
  
  int main() {
      int *iptr = NULL;
      foo(iptr);
      cout << *iptr << endl; // what happens here?
  }
  

Passing pointers by value

• Recall that when you pass a variable by value, a copy is made

  void foo(int *ptr); // Pointer is passed by value
  

• The function receives an address and assigns it to a local pointer variable
• The pointer can change the value at that address in the calling scope, but it can’t change what the pointer points to

void foo(int *ptr);
void bar(int *&ptr);

int x = 0;
int *iptr = &x;

int *ptr; // memory for pointer is on the stack
ptr = new int; // what it points at is on the heap