Lecture 4

We talked last time about arrays, contiguous locations in memory where we can store the same type of data for indexed access. There are other data structures we can build, too.

We also looked at how we might search and sort arrays, with algorithms like:

We started using basic terms to describe running time (in units of steps taken), like:

And the notation for theoretical running time includes:

In the C programming language, string is actually not a real type. Instead, the keywork is provided by the CS50 Library.

But first, let’s think about how we might swap two liquids in two cups. We would need a third cup to hold one of the liquids. Similarly, in programming, to swap the values of two variables, we need some kind of temporary storage.

Let’s take a look at the swap function:

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

Now let’s look at this program:

#include <stdio.h>

void swap(int a, int b);

int main(void)
{
    int x = 1;
    int y = 2;

    printf("x is %i, y is %i\n", x, y);
    swap(x, y);
    printf("x is %i, y is %i\n", x, y);
}

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

But when we run this program, it doesn’t swap the values of x and y in main.

It turns out that, while our algorithm for swapping is correct, our implementation in code doesn’t do what we want for a subtle reason.

Recall that bytes in memory can be visualized as a grid, with each location having some numerical address indicating its position:

Our computer, or more precisely our programs written in C, have some structure to how that memory is used:

We’ll discuss the other areas later, but for now notice we have an area labeled heap at the top and stack at the bottom.

Before we get any further, let’s see what we can find out about addresses with compare0.c:

#include <cs50.h>
#include <stdio.h>

int main(void)
{
    // get two strings
    string s = get_string("s: ");
    string t = get_string("t: ");

    // compare strings' addresses
    if (s == t)
    {
        printf("same\n");
    }
    else
    {
        printf("different\n");
    }
}

Let’s try copy.c:

#include <cs50.h>
#include <ctype.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    // get a string
    string s = get_string("s: ");

    // copy string's address
    string t = s;

    // capitalize first letter in string
    if (strlen(t) > 0)
    {
        t[0] = toupper(t[0]);
    }

    // print string twice
    printf("s: %s\n", s);
    printf("t: %s\n", t);
}

It turns out, string is just a synonym for char *.

What does this mean? Well, let’s look at compare1.c:

#include <cs50.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    // get two strings
    char *s = get_string("s: ");
    char *t = get_string("t: ");

    // compare strings for equality
    if (strcmp(s, t) == 0)
    {
        printf("same\n");
    }
    else
    {
        printf("different\n");
    }
}

But that doesn’t quite explain why we can’t just compare s and t. In the past, when we wrote a line like string s = get_string("s: ");, we were actually creating a variable in memory called s:

s [    ]

Then, whatever the user typed in was stored in some bytes in memory elsewhere:

| S | t | e | l | i | o | s | \0 |

And since we know bytes in memory has a location, or addresses, we can return the location of the first character in the array of characters we just created:

| S | t | e | l | i | o | s | \0 |
 100 101 102 103 104 105 106 107

Assuming that these bytes are numbered something like the above, s will contain the value 100, essentially pointing to the first character. And recall that we know where the string ends, thanks to the use of our NUL character, \0.

Now, we understand why comparing s and t will always show that they’re different, since they’re two different addresses. Each time we call get_string, it stores the input from the user in a different location in memory. So s might have a value like 100, while t has a value like 300, or wherever the second string was stored.

So, to come full circle, s is not actually a string, but a char *, the address of a specific character.

And in C, we call variables that store addresses of other variables pointers. (The * symbol indicates that a variable is a pointer to some other variable type, so we could have int * in addition to char * and others.)

strcmp, we can now infer, must be comparing strings character by character, by going to the addresses that s and t point to.

And in copy0, when we created our variable t and set it to what s was, we were just creating another pointer that pointed to the same string in memory. So when we tried to capitalize t, we were capitalizing the one string that both s and t pointed to.

Let’s look at a program that actually copies strings, copy1.c:

#include <cs50.h>
#include <ctype.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    // get a string
    char *s = get_string("s: ");
    if (!s)
    {
        return 1;
    }

    // allocate memory for another string
    char *t = malloc((strlen(s) + 1) * sizeof(char));
    if (!t)
    {
        return 1;
    }

    // copy string into memory
    for (int i = 0, n = strlen(s); i <= n; i++)
    {
        t[i] = s[i];
    }

    // capitalize first letter in copy
    if (strlen(t) > 0)
    {
        t[0] = toupper(t[0]);
    }

    // print strings
    printf("s: %s\n", s);
    printf("t: %s\n", t);

    // free memory
    free(t);
    return 0;
}

Let’s look at string0.c:

#include <cs50.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    // get a string
    char *s = get_string("string: ");
    if (!s)
    {
        return 1;
    }

    // print string, one character per line
    for (int i = 0, n = strlen(s); i < n; i++)
    {
        printf("%c\n", s[i]);
    }
    return 0;
}

We can replace the loop with printf to read:

...
for (int i = 0, n = strlen(s); i < n; i++)
{
    printf("%c\n", *(s + i));
}
...

We can now start to slowly take away our training wheels of get_int by writing something like this:

#include <stdio.h>

int main(void)
{
    int x;
    printf("x: ");
    scanf("%i", &x);
    printf("x: %i\n", x);
}

We need to pass in the address of x, which we imagined to be something like 500 in the above example.

Going back to our friend noswap.c, we can add lines to our swap function to show that it is indeed working within the function:

...
void swap(int a, int b)
{
    eprinf("a is %i, b is %i\n", a, b);
    int tmp = a;
    a = b;
    b = tmp;
    eprinf("a is %i, b is %i\n", a, b);
}
...

Let’s think back to the closeup of how memory is organized for our program:

We now know enough to solve our problem with swap.c:

#include <stdio.h>

void swap(int *a, int *b);

int main(void)
{
    int x = 1;
    int y = 2;

    printf("x is %i, y is %i\n", x, y);
    swap(&x, &y);
    printf("x is %i, y is %i\n", x, y);
}

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

We can try to get a string, too:

#include <stdio.h>

int main(void)
{
    char *s;
    printf("s: ");
    scanf("%s", s);
    printf("s: %s\n", s);
}

We can create an array of 5 characters for scanf to use:

#include <stdio.h>

int main(void)
{
    char s[5];
    printf("s: ");
    scanf("%s", s);
    printf("s: %s\n", s);
}

But this is also bad, because a longer string that is passed in will start overwriting memory after our array, that we haven’t allocated, which might be storing other things too!

We watch an animated video that tries to explain pointers, Pointer Fun with Binky.

Remember that David, when he was first learning about pointers, didn’t understand them for a while until he was in office hours and a TF walked him through a few times.

When we zoom in on an image, we see something like this:

A black and white smiley face might be represented in binary like this:

With many dots, and many more bits to represent different colors, we can store entire images.

A JPEG file is a particular type of image file, based on a standard the world once agreed upon, that stores images in a particular format. Every JPEG file starts with the same three bytes to identify its format, the values 255 216 255.

Those values are stored in binary, but we can also easily represent them in hexadecimal, a numbering system which uses 16 symbols instead of 10. In addition to the symbols 0-9, we use a, b, c, d, e, and f, for the higher values of 10, 11, 12, 13, 14, and 15.

The number 255, in binary, is 1111 1111; and 216 is 1101 1000. Each of those four bits, since they can hold 16 values, map perfectly to hexadecimal. 1111 is 15 in decimal, or f in hexadecimal, 1101 is 13, or d, and 1000 is 8, also 8. So 255 maps to ff, and 216 to d8. And it’s convention to write hexadecimal as 0xff and 0xd8.

So the first three bytes of a JPEG file are 0xff 0xd8 0xff.

Our problem set this week will involve recovering images from a file of binary data, so knowing that those bytes start a JPEG file will come in useful.

Bitmap files, with the extension BMP, maps bits directly to pixels.

The headers at the beginning of bitmap files are more complicated, and look like this:

We need one more new keyword to easily represent this, a struct. With a struct, we can create a more complicated data type:

typedef struct
{
    string name;
    string dorm;
}
student;

With this syntax, we can group any number of other data types together, and work with them, reading and writing them to disk as well.

In this week’s problem set, we’ll get to work with images and structs. See you there!