Lecture 1

C
hello, world
Compilers
String
Scratch blocks in C
Types, formats, operators
More examples
- Screens
Memory, imprecision, and overflow

C

Today we’ll learn a new language, C: a programming language that has all the features of Scratch and more, but perhaps a little less friendly since it’s purely in text:
```
#include <stdio.h>

int main(void)
{
    printf("hello, world\n");
}
```
- Though the words are new, the ideas are exactly as same as the “when green flag clicked” and “say (hello, world)” blocks in Scratch:
Though cryptic, don’t forget that 2/3 of CS50 students have never taken CS before, so don’t be daunted! And though at first, to borrow a phrase from MIT, trying to absorb all these new concepts may feel like drinking from a fire hose, be assured that by the end of the semester we’ll be empowered by and experienced at learning and applying these concepts.
We can compare a lot of the constructs in C, to blocks we’ve already seen and used in Scratch. The syntax is far less important than the principles, which we’ve already been introduced to.

hello, world

The “when green flag clicked” block in Scratch starts the main program; clicking the green flag causes the right set of blocks underneath to start. In C, the first line for the same is int main(void), which we’ll learn more about over the coming weeks, followed by an open curly brace {, and a closed curly brace }, wrapping everything that should be in our program.
```
int main(void)
{

}
```
The “say (hello, world)” block is a function, and maps to printf("hello, world");. In C, the function to print something to the screen is printf, where f stands for “format”, meaning we can format the printed string in different ways. Then, we use parentheses to pass in what we want to print. We have to use double quotes to surround our text so it’s understood as text, and finally, we add a semicolon ; to end this line of code.
To make our program work, we also need another line at the top, a header line #include <stdio.h> that defines the printf function that we want to use. Somewhere there is a file on our computer, stdio.h, that includes the code that allows us to access the printf function, and the #include line tells the computer to include that file with our program.
To write our first program in Scratch, we opened Scratch’s website. Similarly, we’ll use the CS50 Sandbox to start writing and running code the same way. The CS50 Sandbox is a virtual, cloud-based environment with the libraries and tools already installed for writing programs in various languages. At the top, there is a simple code editor, where we can type text. Below, we have a terminal window, into which we can type commands:
We’ll type our code from earlier into the top, after using the + sign to create a new file called hello.c:
We end our program’s file with .c by convention, to indicate that it’s intended as a C program. Notice that our code is colorized, so that certain things are more visible.

Compilers

Once we save the code that we wrote, which is called source code, we need to convert it to machine code, binary instructions that the computer understands directly.
We use a program called a compiler to compile our source code into machine code.
To do this, we use the Terminal panel, which has a command prompt. The $ at the left is a prompt, after which we can type commands.
- We type clang hello.c (where clang stands for “C languages”, a compiler written by a group of people). But before we press enter, we click the folder icon on the top left of CS50 Sandbox. We see our file, hello.c. So we press enter in the terminal window, and see that we have another file now, called a.out (short for “assembly output”). Inside that file is the code for our program, in binary. Now, we can type ./a.out in the terminal prompt to run the program a.out in our current folder. We just wrote, compiled, and ran our first program!

String

But after we run our program, we see hello, world$, with the new prompt on the same line as our output. It turns out that we need to specify precisely that we need a new line after our program, so we can update our code to include a special newline character, \n:
```
#include <stdio.h>

int main(void)
{
    printf("hello, world\n");
}
```
- Now we need to remember to recompile our program with clang hello.c before we can run this new version.
Line 2 of our program is intentionally blank since we want to start a new section of code, much like starting new paragraphs in essays. It’s not strictly necessary for our program to run correctly, but it helps humans read longer programs more easily.
We can change the name of our program from a.out to something else, too. We can pass command-line arguments, or additional options, to programs in the terminal, depending on what the program is written to understand. For example, we can type clang -o hello hello.c, and -o hello is telling the program clang to save the compiled output as just hello. Then, we can just run ./hello.
In our command prompt, we can run other commands, like ls (list), which shows the files in our current folder:
```
$ ls
a.out* hello* hello.c
```
- The asterisk, *, indicates that those files are executable, or that they can be run by our computer.
We can use the rm (remove) command to delete a file:
```
$ rm a.out
rm: remove regular file 'a.out'?
```
- We can type y or yes to confirm, and use ls again to see that it’s indeed gone forever.
Now, let’s try to get input from the user, as we did in Scratch when we wanted to say “hello, David”:
```
string answer = get_string("What's your name?\n");
printf("hello, %s\n", answer);
```
- First, we need a string, or piece of text (specifically, zero or more characters in a sequence in double quotes, like "", "ba", or “bananas”), that we can ask the user for, with the function get_string. We pass the prompt, or what we want to ask the user, to the function with "What is your name?\n" inside the parentheses. On the left, we want to create a variable, answer, the value of which will be what the user enters. (The equals sign = is setting the value from right to left.) Finally, the type of variable that we want is string, so we specify that to the left of answer.
- Next, inside the printf function, we want the value of answer in what we print back out. We use a placeholder for our string variable, %s, inside the phrase we want to print, like "hello, %s\n", and then we give printf another argument, or option, to tell it that we want the variable answer to be substituted.
If we made a mistake, like writing printf("hello, world"\n); with the \n outside of the double quotes for our string, we’ll see an errors from our compiler:
```
$ clang -o hello hello.c
hello.c:5:26: error: expected ')'
    printf("hello, world"\n);
                         ^
hello.c:5:11: note: to match this '('
    printf("hello, world"\n);
          ^
1 error generated.
```
- The first line of the error tells us to look at hello.c, line 5, column 26, where the compiler expected a closing parentheses, instead of a backslash.
To simplify things (at least for the beginning), we’ll include a library, or set of code, from CS50. The library provides us with the string variable type, the get_string function, and more. We just have to write a line at the top to include the file cs50.h:
```
#include <cs50.h>
#include <stdio.h>

int main(void)
{
    string name = get_string("What's your name?\n");
    printf("hello, name\n");
}
```

So let’s make a new file, string.c, with this code:

#include <stdio.h>

int main(void)
{
    string name = get_string("What's your name?\n");
    printf("hello, %s\n", name);
}

Now, if we try to compile that code, we get a lot of lines of errors. Sometimes, one mistake means that the compiler then starts interpreting correct code incorrectly, generating more errors than there actually are. So we start with our first error:
```
$ clang -o string string.c
string.c:5:5: error: use of undeclared identifier 'string'; did you mean 'stdin'?
  string name = get_string("What's your name?\n");
  ^~~~~~
  stdin
/usr/include/stdio.h:135:25: note: 'stdin' declared here
extern struct _IO_FILE *stdin;          /* Standard input stream.  */
```
- We didn’t mean stdin (“standard in”) instead of string, so that error message wasn’t helpful. In fact, we need to import another file that defines the type string (actually a training wheel from CS50, as we’ll find out in the coming weeks).

So we can include another file, cs50.h, which also includes the function get_string, among others.

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

int main(void)
{
    string name = get_string("What's your name?\n");
    printf("hello, %s\n", name);
}

Now, when we try to compile our program, we have just one error:

$ clang -o string string.c
/tmp/string-aca94d.o: In function `main':
string.c:(.text+0x19): undefined reference to `get_string'
clang-7: error: linker command failed with exit code 1 (use -v to see invocation)

It turns out that we also have to tell our compiler to add our special CS50 library file, with clang -o string string.c -lcs50, with -l for “link”.

We can even abstract this away and just type make string. We see that, by default in the CS50 Sandbox, make uses clang to compile our code from string.c into string, with all the necessary arguments, or flags, passed in.

Scratch blocks in C

The “set [counter] to (0)” block is creating a variable, and in C we would write int counter = 0;, where int specifies that the type of our variable is an integer:
“change [counter] by (1)” is counter = counter + 1; in C. (In C, the = isn’t like an equals sign in a equation, where we are saying counter is the same as counter + 1. Instead, = is an assignment operator that means, “copy the value on the right, into the value on the left”.) And notice we don’t need to say int anymore, since we presume that we already specified previously that counter is an int, with some existing value. We can also say counter += 1; or counter++; both of which are “syntactic sugar”, or shortcuts that have the same effect with fewer characters to type.
A condition would map to:
```
if (x < y)
{
    printf("x is less than y\n");
}
```
- Notice that in C, we use { and } (as well as indentation) to indicate how lines of code should be nested.
We can also have if-else conditions:
```
if (x < y)
{
    printf("x is less than y\n");
}
else
{
    printf("x is not less than y\n");
}
```
- Notice that lines of code that themselves are not some action (if..., and the braces) don’t end in a semicolon.
And even else if:<
```
if (x < y)
{
    printf("x is less than y\n");
}
else if (x > y)
{
    printf("x is greater than y\n");
}
else if (x == y)
{
    printf("x is equal to y\n");
}
```
- Notice that, to compare two values in C, we use ==, two equals signs.
- And, logically, we don’t need the if (x == y) in the final condition, since that’s the only case remaining, and we can just say else.
Loops can be written like the following:
```
while (true)
{
    printf("hello, world\n");
}
```
- The while keyword also requires a condition, so we use true as the Boolean expression to ensure that our loop will run forever. Our program will check whether the expression evaluates to true (which it always will in this case), and then run the lines inside the curly braces. Then it will repeat that until the expression isn’t true anymore (which won’t change in this case).
We could do something a certain number of times with while:
```
int i = 0;
while (i < 50)
{
    printf("hello, world\n");
    i++;
}
```
- We create a variable, i, and set it to 0. Then, while i < 50, we run some lines of code, and we add 1 to i after each run.
- The curly braces around the two lines inside the while loop indicate that those lines will repeat, and we can add additional lines to our program after if we wanted to.
To do the same repetition, more commonly we can use the for keyword:
```
for (int i = 0; i < 50; i++)
{
    printf("hello, world\n");
}
```
- Again, first we create a variable named i and set it to 0. Then, we check that i < 50 every time we reach the top of the loop, before we run any of the code inside. If that expression is true, then we run the code inside. Finally, after we run the code inside, we use i++ to add one to i, and the loop repeats.

Types, formats, operators

There are other types we can use for our variables
- bool, a Boolean expression of either true or false
- char, a single character like a or 2
- double, a floating-point value with even more digits
- float, a floating-point value, or real number with a decimal value
- int, integers up to a certain size, or number of bits
- long, integers with more bits, so they can count higher
- string, a string of characters
And the CS50 library has corresponding functions to get input of various types:
- get_char
- get_double
- get_float
- get_int
- get_long
- get_string
For printf, too, there are different placeholders for each type:
- %c for chars
- %f for floats, doubles
- %i for ints
- %li for longs
- %s for strings
And there are some mathematical operators we can use:
- + for addition
- - for subtraction
- * for multiplication
- / for division
- % for remainder

More examples

For each of these examples, you can click on the sandbox links to run and edit your own copies of them.

In int.c, we get and print an integer:

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

int main(void)
{
    int age = get_int("What's your age?\n");
    int days = age * 365;
    printf("You are at least %i days old.\n", days);
}

Notice that we use %i to print an integer.
We can now run make int and run our program with ./int.

We can combine lines and remove the days variable with:

int age = get_int("What's your age?\n");
printf("You are at least %i days old.\n", age * 365);

Or even combine everything in one line:

printf("You are at least %i days old.\n", get_int("What's your age?\n") * 365);

Though, once a line is too long or complicated, it may be better to keep two or even three lines for readability.

In float.c, we can get decimal numbers (called floating-point values in computers, because the decimal point can “float” between the digits, depending on the number):
```
#include <cs50.h>
#include <stdio.h>

int main(void)
{
    float price = get_float("What's the price?\n");
    printf("Your total is %f.\n", price * 1.0625);
}
```
- Now, if we compile and run our program, we’ll see a price printed out with tax.
- We can specify the number of digits printed after the decimal with a placeholder like %.2f for two digits after the decimal point.
With parity.c, we can check if a number is even or odd:
```
#include <cs50.h>
#include <stdio.h>

int main(void)
{
    int n = get_int("n: ");

    if (n % 2 == 0)
    {
        printf("even\n");
    }
    else
    {
        printf("odd\n");
    }
}
```
- With the % (modulo) operator, we can get the remainder of n after it’s divided by 2. If the remainder is 0, we know that n is even. Otherwise, we know n is odd.
- And functions like get_int from the CS50 library do error-checking, where only inputs from the user that matches the type we want is accepted.
In conditions.c, we turn the condition snippets from before into a program:
```
// Conditions and relational operators

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

int main(void)
{
    // Prompt user for x
    int x = get_int("x: ");

    // Prompt user for y
    int y = get_int("y: ");

    // Compare x and y
    if (x < y)
    {
        printf("x is less than y\n");
    }
    else if (x > y)
    {
        printf("x is greater than y\n");
    }
    else
    {
        printf("x is equal to y\n");
    }
}
```
- Lines that start with // are comments, or note for humans that the compiler will ignore.
- For David to compile and run this program in his sandbox, he first needed to run cd src1 in the terminal. This changes the directory, or folder, to the one in which he saved all of the lecture’s source files. Then, he could run make conditions and ./conditions. With pwd, he can see that he’s in a src1 folder (inside other folders). And cd by itself, with no arguments, will take us back to our default folder in the sandbox.

In agree.c, we can ask the user to confirm or deny something:

// Logical operators

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

int main(void)
{
    // Prompt user to agree
    char c = get_char("Do you agree?\n");

    // Check whether agreed
    if (c == 'Y' || c == 'y')
    {
        printf("Agreed.\n");
    }
    else if (c == 'N' || c == 'n')
    {
        printf("Not agreed.\n");
    }
}

We use two vertical bars, ||, to indicate a logical “or”, whether either expression can be true for the condition to be followed.
And if none of the expressions are true, nothing will happen since our program doesn’t have a loop.

Let’s implement the coughing program from week 0:

#include <stdio.h>

int main(void)
{
    printf("cough\n");
    printf("cough\n");
    printf("cough\n");
}

We could use a for loop:
```
#include <stdio.h>

int main(void)
{
    for (int i = 0; i < 3; i++)
    {
        printf("cough\n");
    }
}
```
- By convention, programmers tend to start counting at 0, and so i will have the values of 0, 1, and 2 before stopping, for a total of three iterations. We could also write for (int i = 1; i <= 3; i++) for the same final effect.
We can move the printf line to its own function:
```
#include <stdio.h>

void cough(void);

int main(void)
{
    for (int i = 0; i < 3; i++)
    {
        cough();
    }
}

void cough(void)
{
    printf("cough\n");
}
```
- We declared a new function with void cough(void);, before our main function calls it. The C compiler reads our code from top to bottom, so we need to tell it that the cough function exists, before we use it. Then, after our main function, we can implement the cough function. This way, the compiler knows the function exists, and we can keep our main function close to the top.
- And our cough function doesn’t take any inputs, so we have cough(void).
We can abstract cough further:
```
#include <stdio.h>

void cough(int n);

int main(void)
{
    cough(3);
}

void cough(int n)
{
    for (int i = 0; i < n; i++)
    {
        printf("cough\n");
    }
}
```
- Now, when we want to print “cough” any number of times, we can just call the same function. Notice that, with void cough(int n), we indicate that the cough function takes as input an int, which we refer to as n. And inside cough, we use n in our for loop to print “cough” the right number of times.
Let’s look at positive.c:
```
#include <cs50.h>
#include <stdio.h>

int get_positive_int(void);

int main(void)
{
    int i = get_positive_int();
    printf("%i\n", i);
}

// Prompt user for positive integer
int get_positive_int(void)
{
    int n;
    do
    {
        n = get_int("%s", "Positive Integer: ");
    }
    while (n < 1);
    return n;
}
```
- The CS50 library doesn’t have a get_positive_int function, but we can write one ourselves. Our function int get_positive_int(void) will prompt the user for an int and return that int, which our main function stores as i. In get_positive_int, we initialize a variable, int n, without assigning a value to it yet. Then, we have a new construct, do ... while, which does something first, then checks a condition, and repeats until the condition is no longer true.
- Once the loop ends because we have an n that is not < 1, we can return it with the return keyword. And back in our main function, we can set int i to that value.

Screens

We might want a program that prints part of a screen from a video game like Super Mario Bros. In mario0.c, we have:
```
// Prints a row of 4 question marks

#include <stdio.h>

int main(void)
{
    printf("????\n");
}
```

We can ask the user for a number of question marks, and then print them, with mario2.c:

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

int main(void)
{
    int n;
    do
    {
        n = get_int("Width: ");
    }
    while (n < 1);
    for (int i = 0; i < n; i++)
    {
        printf("?");
    }
    printf("\n");
}

And we can print a two-dimensional set of blocks with mario8.c:

// Prints an n-by-n grid of bricks with a loop

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

int main(void)
{
    int n;
    do
    {
        n = get_int("Size: ");
    }
    while (n < 1);
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            printf("#");
        }
        printf("\n");
    }
}

Notice we have two nested loops, where the outer loop uses i to do everything inside n times, and the inner loop uses j, a different variable, to do something n times for each of those times. In other words, the outer loop prints n “rows”, or lines, and the inner loop prints n “columns”, or # characters, in each line.

Other examples not covered in lecture are available under “Source Code” for Week 1.

Memory, imprecision, and overflow

Our computer has memory, in hardware chips called RAM, random-access memory. Our programs use that RAM to store data as they run, but that memory is finite. So with a finite number of bits, we can’t represent all possible numbers (of which there are an infinite number of). So our computer has a certain number of bits for each float and int, and has to round to the nearest decimal value at a certain point.

With floats.c, we can see what happens when we use floats:

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

int main(void)
{
    // Prompt user for x
    float x = get_float("x: ");

    // Prompt user for y
    float y = get_float("y: ");

    // Perform division
    printf("x / y = %.50f\n", x / y);
}

With %50f, we can specify the number of decimal places displayed.

Hmm, now we get …

x: 1
y: 10
x / y = 0.10000000149011611938476562500000000000000000000000

It turns out that this is called floating-point imprecision, where we don’t have enough bits to store all possible values, so the computer has to store the closest value it can to 1 divided by 10.

We can see a similar problem in overflow.c:
```
#include <stdio.h>
#include <unistd.h>

int main(void)
{
    for (int i = 1; ; i *= 2)
    {
        printf("%i\n", i);
        sleep(1);
    }
}
```
- In our for loop, we set i to 1, and double it with *= 2. (And we’ll keep doing this forever, so there’s no condition we check.)
- We also use the sleep function from unistd.h to let our program pause each time.
- Now, when we run this program, we see the number getting bigger and bigger, until:
```
1073741824
overflow.c:6:25: runtime error: signed integer overflow: 1073741824 * 2 cannot be represented in type 'int'
-2147483648
0
0
...
```
- It turns out, our program recognized that a signed integer (an integer with a positive or negative sign) couldn’t store that next value, and printed an error. Then, since it tried to double it anyways, i became a negative number, and then 0.
- This problem is called integer overflow, where an integer can only be so big before it runs out of bits and “rolls over”. We can picture adding 1 to 999 in decimal. The last digit becomes 0, we carry the 1 so the next digit becomes 0, and we get 1000. But if we only had three digits, we would end up with 000 since there’s no place to put the final 1!
The Y2K problem arose because many programs stored the calendar year with just two digits, like 98 for 1998, and 99 for 1999. But when the year 2000 approached, the programs would have stored 00, leading to confusion between the years 1900 and 2000.
A Boeing 787 airplane also had a bug where a counter in the generator overflows after a certain number of days of continuous operation, since the number of seconds it has been running could no longer be stored in that counter.
So, we’ve seen a few problems that can happen, but now understand why, and how to prevent them.
With this week’s problem set, we’ll use the CS50 Lab, built on top of the CS50 Sandbox, to write some programs with walkthroughs to guide us.