# Compilation Steps

1. Preprocessing: The preprocessor obeys commands that begin with #, also known as directives
Commands for the preprocessor are called directives. Directives begin with a pound sign, and they do not end with a semicolon.

Example:
```c
#include <stdio.h>
```
2. Compiling. A compiler translates then translates the program into machine instructions. 
3. Linking: The generated objects are combined to create a complete executable.

The preprocessor is typically integrated with the compiler.

# Types
## Strings
A string literal is characters enclosed in double quotation marks.

A newline can be inserted using `\n`.

##  Integers
An integer is a way to store a whole number. In C, integers are signed by default.

Values of an integer type are whole numbers.

Integers are divided into two categories, signed, and unsigned.

If the sign bit is zero, it's a positive value, and if it's 1, the value is negative.

They cal be declared using `[short|long] [signed|unsigned] int`, resulting in 6 possible combinations
C99 adds a `long long` int
## Floats
A float is a decimal value. Slower arithmetic and inexact values are both drawbacks of using floats.

## Characters
In C, a `char` denotes a single byte of arbitrary encoding. 

## Variables
A variable must be declared before it is assigned.

## Arrays
### Finding the size of an array
```c
int arr[10];
// The size of an array can be found by
// determining the number of bytes allocated total and dividing that by the size of each element in the array.
int arr_size = sizeof(arr) / sizeof(arr[0]);

```


# Formatting specifiers
# Standard library
## Formatting specifiers
| Specifier | Function                                                                                                                                                    |
| --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `%d`      | Decimal representation: Display a value as a base 10 (hence the decimal) integer.                                                                           |
| `%f`      | Fixed point decimal representation. Specify the number of places to round to by adding a decimal and a number, eg `%.2f` would round to two decimal places. |
| `%e`      | Exponential floating point number representation.                                                                                                           |
| `%g`      | Either fixed point or exponential representation, whichever has a more compact representation.                                                              |
For number formatting specifiers, the convention is as follows:
`%-a.bX`
`%`: Start of the formatting specifier
`-`: (optional) If included, justify value left in space. Otherwise, justify right in space
`a`: (optional) If included, the size of the field in characters.
`.`: Separator between `a` and `b`. Optional if `b` is not specified
`b`: The number of decimal places to round to
`X`: The type of format to use, and the end of the specifier. Use `d` for integer base 10 (decimal) representation, `f` for fixed point decimal, and `e` for exponential notation, and `g` to select between fixed point and exponential, whichever is shorter.
## `printf`
Used to write a string to stdout with the ability to format variables into the string.

Write a string to standard output. `f` indicates that it's a formatting string. The string will not include move the cursor to a newline, append `\n` to the end of the string to do so. 

Printf accepts a variable number of arguments, the first argument is the formatting string, then following arguments are the arguments to be inserted into the string.

TODO: examples
## `scanf`
Read value(s) from stdin.

`scanf` is to stdin as `printf` is to stdout. 

The format of the input is specified using [formatting specifiers](#Formatting%20specifiers), and all following arguments are pointers pointing to variables to update.


### Examples
```c
// Read a float from standard input into the variable `v`.
float v;
// Here, `v` is uninitialized
scanf("%f", &v);

printf("You input: %f", v);
```

### Behavior
The validity of a `scanf` call is not necessarily checked at compile time, and so the number of outputs specified should match the number of inputs. 

For each formatting specifier specified in the string, `scanf` will attempt to locate an appropriate value in the input, skipping whitespace and newlines if necessary until the beginning of a number is reached.

When asked to read an integer, `scanf` searches for one of:
- A digit
- A plus or minus sign
It will continue to read until it reaches a nondigit (whitespace is not skipped in this case, and it is counted as a nondigit). If it doesn't encounter a valid digit first, it will return early. 

When asked to read a float, `scanf` searches for one of:
- A plus sign or minus sign
- A series of digits (possibly containing a decimal point), followed by an exponent (optional). An exponent consists of the letter `e` or `E`, an optional sign, and one or more digits.
`%e`, `%f`, and `%g` all follow the same rules for recognizing floating point numbers. 

If an ordinary character is included in the pattern matching string, it will be matched then discarded before proceeding to the next character.
## `rand`
```c
// `srand` creates a seed to use for rng
seed = srand(time(NULL));

```