Week 5, continued

No lecture on Monday 10/14 or Friday 10/18 (even though it says so in the syllabus)! There will be a quiz review session on Monday, though, which we’ll announce by e-mail and on the course website. Sections will meet on Monday, but you can attend another section or watch the video online if you want.

Quiz 0 is on Wednesday 10/16.

After Quiz 0, we’ll dive into the world of forensics. David and a few of the teaching fellows will walk around campus taking pictures, but unfortunately delete them from their memory card. It will be your job to recover them!

In the coming weeks, we’ll also talk more about graphics and images. We’ll learn that "link:zoom and enhance" is not really as useful as TV shows and movies would suggest.

What we call "compiling" a program actually consists of four steps:

Lines of code that begin with #, such as #define and #include are pre-processor directives. When you write #include <stdio.h>, it instructs the compiler to fetch the contents of stdio.h and paste them into your program before it begins translating into 0s and 1s. This occurs during the pre-processing step.

Compiling actually involves translating C into assembly language. Assembling translates assembly language to binary. Finally, linking combines the 0s and 1s of your program with 0s and 1s of other people’s code.

To see what’s going on during the compiling step, let’s run clang -S on our hello.c program. This creates a file named hello.S written in assembly language. If you open this up, you’ll see instructions like pushl and movl that manipulate registers, very small memory containers. These instructions vary between CPUs.

The following diagram shows how these four steps of compiling connect with each other:

The CS50 Library is a set of functions and types we provided you to make it easier to get user input. In it, we also defined a string to be a char* until we could reveal to you what a pointer is:

typedef char* string;

Let’s peek at the definition of GetChar:

/**
 * Reads a line of text from standard input and returns the equivalent
 * char; if text does not represent a char, user is prompted to retry.
 * Leading and trailing whitespace is ignored.  If line can't be read,
 * returns CHAR_MAX.
 */
char GetChar(void)
{
    // try to get a char from user
    while (true)
    {
        // get line of text, returning CHAR_MAX on failure
        string line = GetString();
        if (line == NULL)
        {
            return CHAR_MAX;
        }

        // return a char if only a char (possibly with
        // leading and/or trailing whitespace) was provided
        char c1, c2;
        if (sscanf(line, " %c %c", &c1, &c2) == 1)
        {
            free(line);
            return c1;
        }
        else
        {
            free(line);
            printf("Retry: ");
        }
    }
}

Why do we return CHAR_MAX if we fail to get a line of text from the user? GetChar returns a char according to its definition, so we need one char value that signals failure. By convention, this sentinel value is 255, the maximum possible value of a char. That means that we can’t distinguish the case of an error from the case of the user typing the char 255, but since 255 is not something you can type on your keyboard, that’s okay.

sscanf is a function used for scanning formatted strings. Here, we pass it the line of text we got from the user, a format string, and the address of two char variables. sscanf will try to interpret the line of text as two characters in a row and fill in c1 and c2 accordingly. What we’re hoping is that only c1 will actually be populated. If both c1 and c2 are populated, it means the user typed more than one character, which is not what we asked for. If only c1 is populated, then sscanf will return 1 and we can return c1.

Just like we used typedef to create the string type in the CS50 Library, you can use it to define your own types:

#include <cs50.h>

// structure representing a student
typedef struct
{
    int id;
    string name;
    string house;
}
student;

Here we’re defining a variable type named student. Inside of this type, which is actually a struct, there are three variables representing the ID, name, and house of the student. To access these variables within a student, we use dot notation:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

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

#include "structs.h"

// class size
#define STUDENTS 3

int main(void)
{
    // declare class
    student class[STUDENTS];

    // populate class with user's input
    for (int i = 0; i < STUDENTS; i++)
    {
        printf("Student's ID: ");
        class[i].id = GetInt();

        printf("Student's name: ");
        class[i].name = GetString();

        printf("Student's house: ");
        class[i].house = GetString();
        printf("\n");
    }

    // now print anyone in Mather
    for (int i = 0; i < STUDENTS; i++)
    {
        if (strcmp(class[i].house, "Mather") == 0)
        {
            printf("%s is in Mather!\n\n", class[i].name);
        }
    }

    // free memory
    for (int i = 0; i < STUDENTS; i++)
    {
        free(class[i].name);
        free(class[i].house);
    }
}

In line 13, we declare an array of student. We then loop through that array and populate it with data from the user.

There are many different file formats used to store images. One such format is a bitmap, or BMP. A very simple bitmap might use 0 to represent black and 1 to represent white, so a series of 0s and 1s could store a black-and-white image.

More sophisticated file formats like JPEG store 0s and 1s for the image itself but also metadata. In Problem Set 5, you’ll use this fact to detect JPEGs that have been lost on David’s memory card.