<!-- Abstract: CS 211 Computer Architecture Lecture 02: Arrays, Pointers, and Control Flow --> # CS 211 - Lecture 02 ## Arrays, Pointers, and Control Flow Bernhard Firner 2025-09-04 --- ## Review * Our initial goal is learning through repetition --- ## Declaring a Variable * Some examples of integer, floating point (fractional number) and boolean variables: ```C int a = 4; float b = 4.3; bool c = false; ``` --- ## Functions * A function has a return type, a name, and an argument list: ```C //This function takes in an int and returns double that value int doubleInt(int a) { return 2*a; } ``` * It won't work with floats! * C++ has an easy solution * but we're sticking with C for simplicity * What are the differences between an `int` and a `float`? --- ## Integer Ranges * On a 64-bit machine, an `unsigned int` holds values from $0$ to $2^{32}-1$ * An `int` holds negative values, from $-2^{31}$ to $2^{31}-1$ * `unsigned long int` could be 32 or 64 bits * `unsigned long long int` will always be 64 bits * C provides these values so you don't need to guess * `INT_MIN` and `INT_MAX` for `int` * Defined in [limits.h](https://cppreference.com/w/c/header/limits.html) * For fun, try adding $1$ to `INT_MAX` and see what you get! --- ## Floats * Floating point numbers actually represent doing some math * We will get into this more later * No need to stress about it at the moment * If you're interested: [floating point format](https://en.wikipedia.org/wiki/Single-precision_floating-point_format) --- ## Math ```C #include <stdio.h> int main(void) { int a = 4; float b = 4.3; float a_over_b_f = a / b; int a_over_b_i = a / b; printf("%i / %f = %f\n", a, b, a_over_b_f); printf("%i / %f = %i\n", a, b, a_over_b_i); return 0; } ``` --- ## Truncation * `int` types cannot hold fractions, so they are `truncated` * Any fractional value is lost ``` $ ./a.out 4 / 4.300000 = 0.930233 4 / 4.300000 = 0 ``` --- ## Modulo arithmetic * The remainder function, `%`, finds the remainder * If it is nonzero, then an `int` operation will be truncated * e.g. `5 % 4` is non zero, so `5 / 4` will truncate * But it does not work with `float` values! * Examples * `4 % 4 = 0` * `8 % 4 = 0` * `9 % 4 = 1` * `-9 % 4 = -1` * `-12 % -5 = -2` --- ## Dividing by zero * Avoid it ```C #include <stdio.h> int main(void) { int a = 4; float b = 4.3; // This will crash your code // The error will be: // Floating point exception (core dumped) //printf("%i / 0 = %i\n", a, a/0); printf("%f / 0 = %f\n", b, b/0); return 0; } ``` > 4.300000 / 0 = inf --- ## Special values * `inf` and `NaN` (not a number) are special floating point values * You'll see them when you've done something wrong * Infinitely small or large values * Unrepresentable math --- ## What Are argc and argv? * The main function has two arguments * `argc` is the argument count, the number of arguments to your program * `argv` is the argument vector, the string representations of the arguments * These are not known at `compile time`, only at `run time`. * argv is an `array` * a simple data structure with multiple elements --- ## Arrays * To access elements in an array we specify an index inside of square brackets * These things: `[ ]` * The first index is 0 ```C //Access the first element argv[0] //Access the third element argv[2] ``` --- ## Looking at argc and argv example1.c: ```C /* * This is an example program! * To compile code: * gcc example.c -o example */ #include <stdio.h> int main(int argc, char** argv) { // Your program goes here. // Say hello. printf("Hello world!\n"); // Print out argc, the count of the program arguments printf("There are %d arguments.\n", argc); // What's the first argument? printf("The first argument is %s.\n", argv[0]); // Return something. return 123; } ``` <div style="text-align: left; margin-left: 40px;"> Compile with: `gcc example1.c -o example1` Run with: ./example1 </div> --- ## Formats * printf uses the % tokens to determine what to print * See [https://cppreference.com/w/c/io/fprintf.html](https://cppreference.com/w/c/io/fprintf.html) * `%d` and `%i` print signed integers * `%ld` and `%li` are `long` versions, holding larger numbers * `%c` is a single character * `%s` is a string * `%f` is a floating point number * `%.3f` would print with 3 digits of precision * `%p` is a pointer --- ## More `printf` ```C /* * This is an example program! * To compile code: * gcc example4.c -o example */ #include <stdio.h> int main(int argc, char** argv) { printf("The name of the program is %s\n", argv[0]); printf("The first character of the program name is %c\n", argv[0][0]); printf("The first argument is %s\n", argv[1]); printf("The first character of the second argument is %c\n", argv[1][0]); float pi = 3.14159265358979; printf("Pi is about %f, or simply %.3f\n", pi, pi); printf("The first and second arguments are at %p and %p\n", argv[0], argv[1]); return argc; } ``` -v- ``` $ ./a.out test The name of the program is ./a.out The first character of the program name is . The first argument is test The first character of the second argument is t Pi is about 3.141593, or simply 3.142 The first and second arguments are at 0x7fff82006545 and 0x7fff8200654d ``` -v- ``` $ ./././././a.out test The name of the program is ./././././a.out The first character of the program name is . The first argument is test The first character of the second argument is t Pi is about 3.141593, or simply 3.142 The first and second arguments are at 0x7ffc49b1952d and 0x7ffc49b1953d ``` * `./` just means `current directory` in your shell * So you can repeat it as many times as you like --- ## What is a string in C? * The argument vector is an array of strings * A string is an array of characters * Each string ends with a special, null character * Value of 0 * Written `\0` * Use `man ascii` on linux to see all ASCII characters * Or see the [cppreference example](https://cppreference.com/w/c/language/ascii.html) --- ## Array Access * Pointers are numbers that refer to memory locations * e.g. 0x7fff82006545 * Those memory locations are arbitrary on your computer * The OS chooses an arbitrary range for a program * This allows for virtual memory, swap, virtual machines, etc * Not an OS course, so we'll leave it at that * On an embedded device, all memory refers to a physical thing --- ## Diving into arrays * argv looks something like this: <table> <tr> <td><b>index</b></td> <td>0</td> <td>1</td> <td>2</td> <td>...</td> <tr> <td><b>content</b></td> <td>pointer1</td> <td>pointer2</td> <td>pointer3</td> <td>...</td> </tr> </table> <br/> * And `argv[0]` points to something like this: <table> <tr> <td><b>index</b></td> <td>0</td> <td>1</td> <td>2</td> <td>3</td> <td>4</td> <td>5</td> <tr> <tr> <td><b>character</b></td> <td>a</td> <td>.</td> <td>o</td> <td>u</td> <td>t</td> <td>\0</td> </tr> </table> --- ## Going Past the End * You can access past the end of an array * Results are unpredictable * Often a segfault though * This something that makes C difficult --- ## The Assembly > gcc -g -c example4.c -o example4.o\ objdump -d -M intel -S example4.o ```C example4.o: file format elf64-x86-64 Disassembly of section .text: 0000000000000000 <main>: * gcc example4.c -o example */ #include <stdio.h> int main(int argc, char** argv) { 0: f3 0f 1e fa endbr64 4: 55 push rbp 5: 48 89 e5 mov rbp,rsp 8: 48 83 ec 20 sub rsp,0x20 c: 89 7d ec mov DWORD PTR [rbp-0x14],edi f: 48 89 75 e0 mov QWORD PTR [rbp-0x20],rsi printf("The name of the program is %s\n", argv[0]); 13: 48 8b 45 e0 mov rax,QWORD PTR [rbp-0x20] 17: 48 8b 00 mov rax,QWORD PTR [rax] 1a: 48 89 c6 mov rsi,rax 1d: 48 8d 05 00 00 00 00 lea rax,[rip+0x0] # 24 <main+0x24> 24: 48 89 c7 mov rdi,rax 27: b8 00 00 00 00 mov eax,0x0 2c: e8 00 00 00 00 call 31 <main+0x31> printf("The first character of the program name is %c\n", argv[0][0]); 31: 48 8b 45 e0 mov rax,QWORD PTR [rbp-0x20] 35: 48 8b 00 mov rax,QWORD PTR [rax] 38: 0f b6 00 movzx eax,BYTE PTR [rax] 3b: 0f be c0 movsx eax,al 3e: 89 c6 mov esi,eax 40: 48 8d 05 00 00 00 00 lea rax,[rip+0x0] # 47 <main+0x47> 47: 48 89 c7 mov rdi,rax 4a: b8 00 00 00 00 mov eax,0x0 4f: e8 00 00 00 00 call 54 <main+0x54> printf("The first argument is %s\n", argv[1]); 54: 48 8b 45 e0 mov rax,QWORD PTR [rbp-0x20] 58: 48 83 c0 08 add rax,0x8 5c: 48 8b 00 mov rax,QWORD PTR [rax] 5f: 48 89 c6 mov rsi,rax 62: 48 8d 05 00 00 00 00 lea rax,[rip+0x0] # 69 <main+0x69> 69: 48 89 c7 mov rdi,rax 6c: b8 00 00 00 00 mov eax,0x0 71: e8 00 00 00 00 call 76 <main+0x76> printf("The first character of the second argument is %c\n", argv[1][0]); 76: 48 8b 45 e0 mov rax,QWORD PTR [rbp-0x20] 7a: 48 83 c0 08 add rax,0x8 7e: 48 8b 00 mov rax,QWORD PTR [rax] 81: 0f b6 00 movzx eax,BYTE PTR [rax] 84: 0f be c0 movsx eax,al 87: 89 c6 mov esi,eax 89: 48 8d 05 00 00 00 00 lea rax,[rip+0x0] # 90 <main+0x90> 90: 48 89 c7 mov rdi,rax 93: b8 00 00 00 00 mov eax,0x0 98: e8 00 00 00 00 call 9d <main+0x9d> float pi = 3.14159265358979; 9d: f3 0f 10 05 00 00 00 movss xmm0,DWORD PTR [rip+0x0] # a5 <main+0xa5> a4: 00 a5: f3 0f 11 45 fc movss DWORD PTR [rbp-0x4],xmm0 printf("Pi is about %f, or simply %.3f\n", pi, pi); aa: 66 0f ef c0 pxor xmm0,xmm0 ae: f3 0f 5a 45 fc cvtss2sd xmm0,DWORD PTR [rbp-0x4] b3: 66 0f ef d2 pxor xmm2,xmm2 b7: f3 0f 5a 55 fc cvtss2sd xmm2,DWORD PTR [rbp-0x4] bc: 66 48 0f 7e d0 movq rax,xmm2 c1: 66 0f 28 c8 movapd xmm1,xmm0 c5: 66 48 0f 6e c0 movq xmm0,rax ca: 48 8d 05 00 00 00 00 lea rax,[rip+0x0] # d1 <main+0xd1> d1: 48 89 c7 mov rdi,rax d4: b8 02 00 00 00 mov eax,0x2 d9: e8 00 00 00 00 call de <main+0xde> printf("The first and second arguments are at %p and %p\n", argv[0], argv[1]); de: 48 8b 45 e0 mov rax,QWORD PTR [rbp-0x20] e2: 48 83 c0 08 add rax,0x8 e6: 48 8b 10 mov rdx,QWORD PTR [rax] e9: 48 8b 45 e0 mov rax,QWORD PTR [rbp-0x20] ed: 48 8b 00 mov rax,QWORD PTR [rax] f0: 48 89 c6 mov rsi,rax f3: 48 8d 05 00 00 00 00 lea rax,[rip+0x0] # fa <main+0xfa> fa: 48 89 c7 mov rdi,rax fd: b8 00 00 00 00 mov eax,0x0 102: e8 00 00 00 00 call 107 <main+0x107> return argc; 107: 8b 45 ec mov eax,DWORD PTR [rbp-0x14] } 10a: c9 leave 10b: c3 ret ``` --- ## More Examination * Let's have the user supply the index to inspect * But user inputs are strings. We'll have to convert. * We'll use the `atoi` (ascii to int) function from `stdlib.h` * `int atoi(const char* nptr);` * [https://cppreference.com/w/c/string/byte/atoi.html](https://cppreference.com/w/c/string/byte/atoi.html) * `man atoi` --- ## `atoi` example ```C /* * This is an example program! * To compile code: * gcc example5.c -o example */ #include <stdio.h> #include <stdlib.h> int main(int argc, char** argv) { // Get the index to inspect int index = atoi(argv[1]); printf("The character at the desired index is %c\n", argv[0][index]); return 0; } ``` --- ## Outputs ``` $ ./a.out 0 The character at the desired index is . $ ./a.out 1 The character at the desired index is / $ ./a.out 2 The character at the desired index is a $ ./a.out 3 The character at the desired index is . $ ./a.out 4 The character at the desired index is o $ ./a.out 5 The character at the desired index is u $ ./a.out 6 The character at the desired index is t $ ./a.out 7 The character at the desired index is $ ./a.out 8 The character at the desired index is 8 $ ./a.out 9 The character at the desired index is $ ./a.out 10 The character at the desired index is $ ./a.out 11 The character at the desired index is S $ ./a.out 12 The character at the desired index is H $ ./a.out 13 The character at the desired index is E $ ./a.out 14 The character at the desired index is L $ ./a.out 15 The character at the desired index is L $ ./a.out 16 The character at the desired index is = $ ./a.out 17 The character at the desired index is / $ ./a.out 18 The character at the desired index is b $ ./a.out 19 The character at the desired index is i $ ./a.out 20 The character at the desired index is n $ ./a.out 21 The character at the desired index is / $ ./a.out 22 The character at the desired index is b $ ./a.out 23 The character at the desired index is a $ ./a.out 24 The character at the desired index is s $ ./a.out 25 The character at the desired index is h $ ./a.out 26 The character at the desired index is $ ./a.out 27 The character at the desired index is L $ ./a.out 28 The character at the desired index is A $ ./a.out 29 The character at the desired index is N $ ./a.out 30 The character at the desired index is G $ ./a.out 31 The character at the desired index is U $ ./a.out 32 The character at the desired index is A $ ./a.out 33 The character at the desired index is G $ ./a.out 34 The character at the desired index is E $ ./a.out 35 The character at the desired index is = $ ./a.out 36 The character at the desired index is e $ ./a.out 37 The character at the desired index is n $ ./a.out 38 The character at the desired index is _ $ ./a.out 39 The character at the desired index is U $ ./a.out 40 The character at the desired index is S $ ./a.out 3294862 Segmentation fault (core dumped) ``` --- ## What? * The OS kills your program (Segmentation fault) if you reach outside of your memory * However, some memory is accessible to you * In this case, the environment variables * Other languages are more safe, but not C! * Remember, it's just a light wrapper over assembly --- ## Pause * Any questions or confusion so far? --- ## Checks and Safety * We obviously need to be careful, but how? * This requires control flow and logic * More common are: * `if` * `while` * `for` * `do-while` and `switch` for special cases * Jumps, including the infamous `goto` --- ## Notes on boolean logic * C has a type named `bool` * It has one of two values * `true` * `false` * `true` and `false` can be treated as `1` and `0` * Until C23, `#include <stdbool.h>` was required for the names * Note: gcc on ilab isn't using C23 by default * You can enable that standard with `gcc --std=c2x` * We are sticking with the default compatibility for now --- ## Boolean operators * A set of logical operators * `!` (not), `&&` (and), `||` (or) * [https://cppreference.com/w/c/language/operator_logical.html](https://cppreference.com/w/c/language/operator_logical.html) * And a set of comparison operators * [https://cppreference.com/w/c/language/operator_comparison.html](https://cppreference.com/w/c/language/operator_comparison.html) * `==` (equality) and `!=` (inequality) * `>` (greater than) and `<` (less than) * `>=` (greater than or equal) and `<=` (less than or equal) --- ## Logical Operators: Equality * `==` tests equality * These expressions evaluate to `true` * `4 == 4` * `2.3 == 2.3` * `'f' == 'f'` * These expressions evaluate to `false` * `4 == 3` * `2.3 == 2.0` * `'f' == 'q'` --- ## Logical Operators: Inequality * `!=` is the opposite of `==` * These expressions evaluate to `false` * `4 != 4` * `2.3 != 2.3` * `'f' != 'f'` * These expressions evaluate to `true` * `4 != 3` * `2.3 != 2.0` * `'f' != 'q'` --- ## Logical Operators: Comparison * Less than: `<` * Greater than: `>` * Less than or equal: `<=` * Greater than or equal: `>=` * Examples * `4 < 5` * `4 <= 4` --- ## Negation * If we want to negate a boolean value we use `!` * These expressions are all true: * `true == true` * `!(false) == true` * `!(4 == 5) == true` --- ## Using Boolean Values * Boolean values are used to control the flow of your program * If X then Y * Syntax is like this: ```C if (X) { //Code that happens when X is true } ``` --- ## `if` syntax * [https://cppreference.com/w/c/language/if.html](https://cppreference.com/w/c/language/if.html) * if (expression) statement-true * if (expression) statement-true else statement-false * I prefer to always use `{` and `}` * Even if the statement is a single line * I personlly think it improves readability --- ## Else * Doing thing A or thing B is common ```C if (X) { //Code that happens when X is true } else { //Code that happens when X is false } ``` --- ## Chaining if...else Statements ```C if (X) { //Code that happens when X is true } else if (Y) { //Code that happens when X is false but Y is true } else { //Code that happens when X and Y are both false } ``` Notice that the second pair of `if ... else` is a single statement, not some new syntax. --- ## Control Flow with `goto` ```C /* * To compile this code: * gcc example6.c -o example6 */ #include <stdio.h> #include <stdlib.h> int main(int argc, char** argv) { if (argc < 2) goto abort; // Get the index to inspect int index = atoi(argv[1]); if (index > 6) goto abort; printf("The character at the desired index is %c\n", argv[0][index]); abort: return 0; } ``` This is the kind of antiquated code that causes pain and suffering --- ## Use `if` over `goto` ```C /* * To compile this code: * gcc example7.c -o example6 */ #include <stdio.h> #include <stdlib.h> int main(int argc, char** argv) { if (argc >= 2) { // Get the index to inspect int index = atoi(argv[1]); if (index < 7) { printf("The character at the desired index is %c\n", argv[0][index]); } } return 0; } ``` --- ## Iterating * Before, w hard-coded the length of `argv[0]`, which is bad ```C /* * To compile this code: * gcc example8.c -o example8 */ #include <stdio.h> #include <stdlib.h> int getlen(char* arg) { int index = 0; while (arg[index] != '\0') { index += 1; } return index; } int main(int argc, char** argv) { if (argc >= 2) { // Get the index to inspect int index = atoi(argv[1]); int len = getlen(argv[0]); if (index < len) { printf("The character at the desired index is %c\n", argv[0][index]); } } return 0; } ``` --- ## A Note on Scope * `index` is declared twice * But in different `scopes` * [https://cppreference.com/w/c/language/scope.html](https://cppreference.com/w/c/language/scope.html) ```C[10,20] /* * To compile this code: * gcc example8.c -o example8 */ #include <stdio.h> #include <stdlib.h> int getlen(char* arg) { int index = 0; while (arg[index] != '\0') { index += 1; } return index; } int main(int argc, char** argv) { if (argc >= 2) { // Get the index to inspect int index = atoi(argv[1]); int len = getlen(argv[0]); if (index < len) { printf("The character at the desired index is %c\n", argv[0][index]); } } return 0; } ``` --- ## More on Scope * `Scope` refers to the visibility of a name * One easy trick is to track the `{ }` * Anything declared inside of a `{ }` pair is only visible inside of that `{ }` * Not a complete story, but good enough for now * `#include` statements bring new symbols into `global` scope * Meaning that everything in the file can now access them * We could use `atoi` anywhere in our program, for example --- ## Iterating over a string * Use `putchar` from `stdio` to print in a `while` ```C /* * To compile this code: * gcc example9.c -o example9 */ #include <stdio.h> #include <stdlib.h> int getlen(char* arg) { int index = 0; while (arg[index] != '\0') { index += 1; } return index; } void print(char* str) { int index = 0; int len = getlen(str); while (index < len) { putchar(str[index]); ++index; } // We don't return anything // NOTE: Pedantically, there should be error checking } int main(int argc, char** argv) { int index = 0; while (index < argc) { // Print out the argument and a new line. print(argv[index]); putchar('\n'); ++index; } return 0; } ``` --- ## Notes * Before we used the `+=` operator * Adding the value on the right to the variable on the left * To increment or decrement by 1, we can use `++` or `--` * Our function doesn't need to return anything * So the return type is `void` --- ## Iterating over a string * `for` version ```C /* * To compile this code: * gcc example10.c -o example10 */ #include <stdio.h> #include <stdlib.h> int getlen(char* arg) { int index = 0; while (arg[index] != '\0') { index += 1; } return index; } void print(char* str) { int len = getlen(str); for (int index = 0; index < len; ++index) { putchar(str[index]); } // We don't return anything // NOTE: Pedantically, there should be error checking } int main(int argc, char** argv) { int index = 0; while (index < argc) { // Print out the argument and a new line. print(argv[index]); putchar('\n'); ++index; } return 0; } ``` --- ## Notes on `for` * [https://cppreference.com/w/c/language/for.html](https://cppreference.com/w/c/language/for.html) * Four parts: 1. init clause 2. conditional expression 3. iteration expression 4. loop statement * The first three are inside of the parenthesis ```C for (init clause; conditional expression; iteration expression) statement ``` --- ## More notes * Every part of the for loop has its own scope * This means we could not use it in the `getlen` function ```C int getlen(char* arg) { // Empty loop statement is okay for (int index = 0; arg[index] != '\0'; index += 1); // But index does not exist here--it is out of scope return index; } ``` --- ## Even more notes * You can do weird things, like leave sections empty ```C int getlen(char* arg) { int index = 0; for (; arg[index] != '\0'; index += 1); return index; } ``` * Some people write infinite loops with `for` rather than `while` * `for(;;) { ... }` * `while (true) { ... }` * Focus on clarity --- ## Next Class * Creating our own arrays * Writing an algorithm