vault backup: 2025-01-07 18:14:44

education/computer engineering/ECE1400/C.md

@@ -0,0 +1,136 @@
+# 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]);
+
+```
+
+# Pointers
+`&` gives you the address of a variable
+`*` gives you the value in memory that an address points to.
+
+To update the value a pointer points at, you can dereference on the left hand side of the assignment operator:
+```c
+// Update the value `p` points at to be 7
+*p = 7;
+```
+
+Because of how operator precedence works, parentheses should be placed around the dereference operator and the variable
+```c
+// Increment the value pointed to by `p`
+(*p)++;
+```
+# 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
+srand(time(NULL));
+
+// `rand` generates a random integer between 0 and `RAND_MAX`
+// To pick a number between a particular range, you can use the modulo
+// operator.
+// The below example picks a number between zero and four.
+int num = rand() % 4;
+
+```