Computer Programming (10) - Arrays and Strings

administrivia

pointer subtraction

• subtraction with pointers follows the same logic as addition, but the rules are necessarily different
  • instead of moving forward in the array, as addition does, we're moving backwards
  • so given the declarations:

    int a[8]; int *p = a+4;

• p now points to element a[4], the fifth element of a
• the expression p-2 evaluates to a pointer to a[2], the third element of a.

example

int a[8]; int *p, *q; p = a+4; q = p-2;

example

int a[8]; int *p, *q; p = a+4; q = p-2;

example

int a[8]; int *p, *q; p = a+4; q = p-2;

pointer subtraction

• just like with addition, the - operator can take a pointer and an integer as operands
  • but you can only subtract an integer from a pointer, not vice versa
    • you can go 2 lockers to the left of locker #583
    • you can't go locker #583 to the left of 2
• but unlike addition, you can subtract one pointer from another
  • as long as the two pointers point to exactly the same type

pointer-pointer

• you can think of this algebraically:
  • given the following declarations:

    int a[8]; int *p1 = a+2; int *p2;

  • if
    • p2 = p1 + 3
  • then
    • p1 == p2 - 3
  • and
    • p2 - p1 == 3

pointer subtraction

• gives us the number of "things" between the two pointers.

  int a[8]; int *p = &a[1]; int *q = &a[4];

  

back to our example

#include <stdio.h> int inputScores (double *); void printStats (double *, int); int main (void) { double scores[250]; int numScores; printf ("Scores: a program to compute grade statistics.\n"); printf ("Enter all scores, finish with –1:\n\n"); numScores = inputScores (scores); printStats (scores, numScores); }

• now we need to write the two functions
  • inputScores
  • printStats

what's this supposed to do again?

• let's keep things simple: imagine there are only 5 students in my class
  • they get the following scores on an exam: 57, 85, 97, 16, 82
  • this is what I'd like my program to do:

  Scores: a program to compute grade statistics. Enter all scores, finish with -1: 57 85 97 16 82 -1 Average: 61.4 Median: 82 Standard Deviation: 32.2

printStats()

• so the printStats function should:
  • take the array and the number of scores as arguments
    • remember that our array can hold up to 250 scores
    • but that doesn't mean that all 250 were entered
  • it should compute the average, median, and standard deviation, and print them out
  • the function declaration is this:

    void printStats (double *, int);

so let's write the function

• first of all, we need to give names to our parameters
  • the declaration doesn't need names; all it needs are the data types
  • but the actual function definition is declaring local variables to use within the function; these variables need names
• we also can put in the braces that will surround the code for the function

void printStats (double *scores, int numScores) { ... }

---

so what's the function going to do?

• it must:
  • compute the average
  • compute the median
  • compute the standard deviation
  • print the statistics
• let's punt on the math for now
  • after all, this is a computer class, not a statistics class
  • we'll just use three more functions, which we can write later

our function so far

double computeAverage (double *, int); double computeMedian (double *, int); double computeStandardDev (double *, int); void printStats (double *scores, int num) { double average; double median; double stdDev; average = computeAverage (scores, num); median = computeMedian (scores, num); stdDev = computeStandardDev (scores, num); printf ("Average: %5.1f\n", average); printf ("Median: %5.1f\n", median); printf ("Standard deviation: %5.1f\n", stdDev); }

how would we do those functions?

/* * computeAverage: calculate and return the average * of the numbers in an array */ double computeAverage (double *array, int size) { int i; double sum = 0.0; for (i = 0; i < size; ++i) sum += array[i]; return sum/size; }

next

• now we have to implement inputScores

  int inputScores (double *);

• what this will do:
  • keep reading numbers from the keyboard until the user enters a negative number
  • store all the entered numbers in the array
  • return the number of entries
• so as before, let's set things up for the code

  int inputScores (double *scores) { ... }

function inputScores

• now what?
  • we want to do the following:
    • read a number
    • if it's negative, return
    • otherwise, store it in the array
    • increment a running count of the number of entries
    • and go back to read another one
  • doesn't this sound a lot like a loop?
    • we're repeating the same steps over and over

choosing a loop

• we have 3 main kinds of loops at our disposal
  • for
  • while
  • do while
• how do we choose?
  • in reality, we could use any of the three

inputScores using while

• here's one way to do it:

  int inputScores (double *scores) { int count = 0; double score; scanf ("%lf", &score); while (score >= 0.0) { scores[count] = score; count += 1; scanf ("%lf", &score); } return count; }

inputScores using while

• or slightly more compact:

  int inputScores (double *scores) { int count = 0; double score; scanf ("%lf", &score); while (score >= 0.0) { scores[count++] = score; scanf ("%lf", &score); } return count; }

another inputScores

int inputScores (double *scores) { int count = 0; double score; scanf ("%lf", &score); while (score >= 0.0) { scores[count++] = score; scanf ("%lf", &score); } return count; }

what's a string?

• strings are how we store and manipulate text in C
  • they're made up of characters
  • they're basically arrays of char
• strings are not a unique data type in C
  • but C does have some special stuff to deal with strings

array of char

• if you declare an array of chars like this:

  char carray[14];

• what have you declared?
  • really, just a bunch of adjacent bytes in memory
  • not too dissimilar to our earlier arrays of ints
    • except each element is 1 byte instead of 4
  

initializing arrays of char

• just like any array, we can initialize an array of chars:

  char carray[14] = {'H', 'e', 'l', 'l', 'o'};

• remember our rules of array initialization
  • we can have as many initializers as we have array elements
  • we can have fewer, but not more
  • if we have fewer, the remaining elements get set to 0
  

implied-length initialization

• we can let the compiler figure out how big to make the array
  • just by leaving the square brackets empty

    char carray[] = {'H', 'e', 'l', 'l', 'o'};

  • since there are 5 initializers, the compiler makes a 5-element array
  

problem

• how does the computer know how long a string is?
  • the answer is, it doesn't
  • just like our scores array, we can use as much or as little of the array as we like
  • so here we've used 5 of the 14 bytes
  • and we can tell by looking, because the rest is set to 0
  

but that's not always true

• here's our other case - where we sized the array implicitly
  • since we don't know what comes next in memory, we can't tell by looking where the array ends
  • it may well not be a 0
  

strings vs. arrays of char

• C adds a convention here about how strings are stored.
  • they're stored in arrays of char, but there's more to a string than just that
  • the convention is that an extra character is added to the end of the string
    • this is the nul character - ASCII value 0

so our initialization should have been

char cstring[] = {'H','e','l','l','o','\0'};

string literals

• sometimes called "string constants"
• a string literal is a sequence of zero or more characters enclosed in double quotes
  • like this: "xyz" or "Hello, world!\n"
  • we've already used these a lot

what are string literals?

• when we use a string literal in our code:

  printf ("Hello, world!\n");

  • the compiler sets up a character array in memory for us, just long enough to hold the string
  • the array is initialized using the contents of the string, with a null character ('\0') added to the end
  • and just like any array, when we use it in a context where we would be getting the value of a variable, we get a pointer to the first byte of the string.
  

so let's check that

• let's look at the function prototype for printf
  • which, as we should remember, is in the file stdio.h

  extern int pclose(FILE *); extern FILE * popen(const char *, const char *); extern int printf(const char *, ...); extern int putc(int, FILE *); extern int putchar(int);

printf declaration

• we don't know enough to fully understand this, but let's talk about what we can…

  extern int printf(const char *, ...);

  • this declaration says that the identifier printf is the name of a function
    • that function may be defined externally to the current file
    • the function returns an int
    • it takes at least one argument
      • that argument is a const char *

const char *

• what's that "const" thing?
  • it's another storage class specifier
  • it says that, for a variable or array, the value(s) in it cannot be altered
  • in this case, it means that printf gets an argument that is a pointer to the first character of a string
    • but printf promises it won't change the contents of that string

printf argument

• so remember, we have always (so far) called printf with a string literal as the first argument
• and what printf is actually passed is a pointer to a char (which is the beginning of a string)

using strings

• so the first thing we can do with a string is create one. We've seen a clumsy way to do this earlier:

  char cstring[] = {'H','e','l','l','o','\0'};

  • but this could get really tedious to initialize long string variables!
  • so C gives us a nicer way:

    char cstring[] = "Hello";

two similar but different strings

• we just created a string named cstring

  char cstring[] = "Hello";

  • but the following is legal too:

  char *pstring = "Hello";

  • they look very similar, but it's important to keep them distinct

comparison

• we've already said what the first one does:

  char cstring[] = "Hello";

  

comparison

• the second is a little more complex

  char *pstring = "Hello";

  • we're declaring a variable named pstring, so the compiler will reserve some memory for it
    • it's a pointer to a char
  

comparison

• the second is a little more complex

  char *pstring = "Hello";

  • whenever we use a literal, the compiler sets up an array for us
    • we don't know where in memory it will do this, but we shouldn't care
    • we just get a pointer to it, wherever it is
  

comparison

• the second is a little more complex

  char *pstring = "Hello";

  • and finally, the pointer pstring is initialized to the address of the array that was created for us
  

so what's the difference?

char cstring[] = "Hello"; char *pstring = "Hello";

• the first creates an array variable
  • we "own" the whole thing
    • we created it
    • we can change the contents
• the second creates a pointer variable
  • we "own" the pointer
    • we can change its value to point somewhere else
  • but the compiler created the string for us
    • we are not supposed to change its contents

but the two are very similar

char cstring[] = "Hello"; char *pstring = "Hello";

• remember that in most contexts, when we use the name of an array variable, we get a pointer to the first element
  • that means that in many cases, these two variables can be used interchangeably

    printf (cstring); printf (pstring);

what else can we do with strings?

• we can make an array of pointers to strings

  char *dayName[] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};

  • this makes an array of 7 elements
  • each element is a char *
  • each element is initialized with a pointer to one of those string literals
  • this is very useful:

    printf ("%s\n", dayName[i]);