Programming in C

Lecture Outline

Aims and Objectives
Pointers and Addresses
The Organisation of Memory
Pointers and Arrays
2-dimensional character Arrays
Managing Memory
Arrays and Memory Manipulation

• Pointers and Addresses

• Organisation of Memory

• Pointers and Arrays

• Managing Memory

• Manipulating Memory

• A pointer is a variable that contains the address (in memory) of a variable

• Normally, you can only pass the values of parameters to functions, and you can only update one variable in the calling function

• Let's say you want a function validwhich takes a user action and a context in which that action is performed. We want to check if the user action is valid for the context, and, if the action is invalid, then we want to return an error number which we can report to the user. We want to use the function in a conditional, so it must return a zero, if the user action is invalid, as well as returning the error code.

  if (!valid(user_action, context))
  	print_error_message(user_action, context, error_code);
  /*                                        */
  

• error_code would have to be defined as an extern, but if you have many functions which must return two or more values, then the programs will become unreadable!

• With pointers, you can do call by reference. Your function can still (in reality) return only one value, but the function can update the original values of other parameters

• There are two operators
  • & retrieves the address of a variable (pointer)

  • * allows you to access a variable through its pointer

• Physical memory is organised as a uni-dimensional array, each cell is a byte in size, and each cell is sequentially numbered from 0 to however much memory is available.

• C, however, does do some abstraction for you. If you reference a byte location, and C knows that the data stored at that byte is actually spread out over 4 bytes (e.g., a float), then C will retrieve / update all of the data for you.

• A pointer also takes up room in memory, but (typically) the contents of memory at the pointer's location will be the address of some other variable (indirect addressing)

• Pointers are variables, and so must be declared

  int *ip; /* declares ip to be a pointer to an integer */

• ip cannot now be used to point to floats, doubles, or chars. Remember, C knows how much memory to reference according to the data's data type! A pointer, and the variable at which it will be pointing MUST have the same data type.

  if (! valid(a, b, &error_code)) {
  	print_error_message(a, b, error_code);
  }
  
  int test_range(int a, int b, int *error_code)
  {
  	int in_error = 1;
  
  	if (b == 1 && a > 2) {
  		in_error = 0;
  		if (a == 3) { 
  			*error_code = 1;
  		} else if (a == 4) {
  			*error_code = 2;
  		} ...
  	}
  	return in_error;
  }
  

• The function showed how to implement call by reference

• But you can also create pointers as normal variables

  main()
  {
  	int a = 4, b = 7;
  
  	int *ip; /* ip just declared as a pointer */
  
  	ip = &a; /* ip now points to a */
  
  	*ip = 10; /* a now = 10 */
  
  	b = *ip; /* b also equal to 10 */
  
  /* .... */
  
  }
  

• Things you can do with pointers

  *ip = value	/* update address */
  ip = &variable	/* point to variable */
  ip = 0	/* for conditionals */
  ++ip	/* point to next logical cell */
  --ip	/* point to previous logical cell */
  ++*ip	/* increment value at ip */
  --*ip	/* decrement value at ip */
  ip + integer	/* point to cell */
  ip - integer	/* point to cell */
  *ip op integer	/* update variable at ip */

• We have been passing arrays to functions, but we have been able to amend the contents of the array from within the function

  void strcopy(char b[], char a[]);
  
  main()
  {
  char another_str[] ="Hello, world", string[20];
  
  	strcopy(string, another_str);
  	printf("%s\n", string);
  }
  
  void strcopy(char b[], char a[])
  {
  	int i;
  
  	for (i = 0; a[i] != '\0'; i++)
  		b[i] = a[i];
  	b[i] = '\0';
  }
  

• This is because C does not pass a copy of the array to the function, it passes the address of the first array cell!

• The following program is equivalent to the above

  void strcopy(char *b, char *a);
  
  main()
  {
  char another_str[] ="Hello, world", string[20];
  
  strcopy(string, another_str); /* No & needed */
  printf("%s\n", string);
  }
  
  void strcopy(char *b, char *a)
  { 
  	while (*b++ = *a++)
  	;
  }
  

• Let's say we want to hold the names of the months in an array

• Now, the names of the month are themselves going to be character arrays, e.g., "January"

• How can we create a two-dimensional array, such that a call to the 10th cell will return "October"?

  char months[13][10] = /* 13 months, max len 10 */

  {"","January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"};

• Now, the array occupies 130 bytes, although some of the elements are shorter than their allocation

• If the array is very large, or the elements differ enormously in their lengths, then this is quite wasteful

• It would be better if we could hold the array as a uni-dimensional array, with another array of fixed size which could be used to hold information about where each element started

  char months[] =

  " JanuaryFebruaryMarchAprilMayJuneJulyAugustSeptemberOctoberNovemberDecember";

• You can create an array of pointers. This array can be tightly bound to months[], and will contain information about where each array element starts

• But first, we need to be able to manage memory. We will create a (large) vector to hold the elements, and we will allocate extra memory when we add another element, and deallocate (free) chunks of memory

• We need two functions

  char *alloc(int n) /* return pointer to n chars */
  void mfree(char *p) /* free storage from p */
  

• C provides two functions malloc() and free() to do the same things, but we want to see how C does it

• We are going to create a fixed size stack (emulating buffered memory), and alloc() will tell us where we can place our next element (by returning a pointer to the first character position), and mfree() is just going to reset the pointer

  #define SIZE 10000 /* size of stack */
  
  static char allocbuf[SIZE]; /* stack */
  static char *allocp = allocbuf; /* free pos */
  
  char *alloc(int n)
  {
  	if (allocbuf + SIZE - allocp >= n) { 
  	/* there is enough available space */
  		allocp += n; /* next free space */
  		return allocp - n; /* space allocated */
  	} else
  			return 0; /* request denied */
  }
  
  void mfree(char *p)
  {
  	if (p >= allocbuf && p < allocbuf + SIZE)
  	/* *p is pointing to element inside stack */
  		allocp = p;
  }
  

• This is fairly rudimentary, but it serves our purpose at present

• Now that we can allocate and free memory we can create an array of pointers which will allow us to squeeze data into a uni-dimensional array

  #include <stdio.h>
  #include <string.h>
  
  #define MAXLEN 80 /* max length of input line */
  int getline(char *, int);
  char *alloc(int);
  
  /* read input lines */
  int readlines(char *lineptr[], int maxlines)
  {
  	int len, nlines;
  	char *p, line[MAXLEN];
  
  	nlines = 0;
  	while ((len=getline(line, MAXLEN)) > 0)
  		if (nlines >= maxlines || (p = alloc(len)) == NULL)
  			return -1; /* no space */
  		else {
  			line[len - 1] = '\0'; /* delete \n */
  			strcpy(p, line);
  			lineptr[nlines++] = p;
  		}
  	}
  	return nlines;
  }
  

• readlines() can be called with

  readlines(char *lineptr[], int maxlines)
  

• Manipulating a large character array, e.g., sorting it, can be time consuming, because you would have to move individual elements one character at a time

• However, if the pointer array (which contains integer elements, even though it points to a char) is used to 'view' the large character array, then string manipulation becomes easy

     array[0]         ------------->      "January"           
     array[1]         ------------->      "February"      
     array[2]         ------------->      "March"        

• Each array reference is a pointer to the location of some data in memory

• So to sort an array, it is not necessary to copy the contents of one element into another element one character at a time

• It is only necessary to change the address that each pointer points to

  void swap(char a[], char b[])
  {
  	int i;
  	char temp[MAX];
  
  	/* if the elements need swapping then */
  	for (i = 0; b[i] != '\0'; i++)
  		temp[i] = b[i];
  	temp[i] = '\0';
  	for (i = 0; a[i] != '\0'; i++)
  		b[i] = a[i];
  	b[i] = '\0';
  	for (i = 0; temp[i] != '\0'; i++)
  		a[i] = temp[i];
  	a[i] = '\0';
  }
  

• The function is going to be very slow

• A more efficient version, involving only the pointers, is

  void swap(char *a[], int i, int j)
  {
  	char *temp;
  
  	temp = a[i]; a[i] = a[j]; a[j] = temp;
  }
  

Some useful examples...

Next Lecture...