CS 200: Concepts of Programming with C++

4.1.1. Files, directories, and the filesystem

4.1.2. Terminal aka shell aka command line

4.2.1. Compiler - g++

4.2.2. make

4.2.3. Git

4.2.4. GitLab

4.2.5. Debugger - gdb

4.2.6. Debugger - lldb

4.2.7. IDE - emacs

4.2.8. IDE - vs code / vs codium

5.1.1. 📚 Intro: Navigating the course

5.1.2. 📚 Intro: Computer Basics - The Filesystem

1. Files, directories, and the filesystem
   

   On your computers, tablets, and phones, there is a filesystem structure that organizes all the files on your system - Programs, images, videos, documents, and so on. Being able to navigate your system's files is an important part of computer literacy, and will help with locating your source code and built programs. The filesystem is a representation of items on your device's hard-drive.

   1. Files
      

      Files on your computer can be text documents, images, videos, audio, or even executable programs (apps). Each file has a name and usually has an extension. The extension is a short-cut for you to tell what type of file the item is. Some common file types are:

      Document extension	File type
      FILENAME.docx	MS Word document
      FILENAME.xlsx	MS Excel document
      FILENAME.mp4	Video file
      FILENAME.mp3	Audio file
      FILENAME.jpg	Image file
      FILENAME.png	Image file
      FILENAME.zip	Compressed file

      If you're on Windows, I would recommend turning on file extension view so you can see what kind of files are what.

      1. Go to the Start Menu and type "Folder options" and select the "File Explorer Options".

         

      2. Open the "View" tab, then UNCHECK the "Hide extensions for known file types" box. Click "OK" afterwards.

         

   2. Folders/directories
      

      Besides files, the filesystem is also split up into folders (also known as directories). Folders have a name but no file extension - they're not files. They are just locations that store files and other folders. A folder inside of another folder is known as a subfolder.

      For instance, in your Photos directory on your computer, you might keep separate folders for different dates ("2025", "2026"), or different projects ("Landscapes") or anything else. On your tablets and phones, you can make "Albums", and behind-the-scenes these become Folders on your device.

      

      Figure 1: Side-by-side screenshots from my Android device: The view of Albums from my Photos app, and then the actual folders on the Filesystem.

      The filesystem on our devices are structured like a tree (though usually drawn like an up-side-down tree), where we have one root location (the base) and it expands into various folders and sub-folders.

      Filesystem in Windows
      

      Filesystem in Linux
      

      On Windows your primary hard-drive is usually put as the C:\ drive. (If your computer has multiple hard-drives, you might also have D:\, E:\, etc. - CD drives also will get a letter drive as well!)

      On Linux and Mac, the root directory is written as just a forward slash /, though you usually won't access the root directory because it's full of system files.

      When you open up the File Explorer in Windows it starts you at a "Home" directory, which usually has folders for "Pictures", "Documents", and more.

      With Mac/Linux, usually you'll also start at a home folder. The path for this is usually at /home/YOURNAME/, and this directory also usually has a "Photos", "Documents", and other similar folders.

   3. Paths
      

      As we organize our files on our system within folders and subfolders, our files will have a filepath that corresponds to their locations. The filepath is the instructions for how to get to your folder or file, starting from the root directory (C:\ or /) and through every folder on its way.

      For example, on Windows, many programs are stored in C:\Program Files, such as Firefox (C:\Program Files\Mozilla Firefox), Zoom (C:\Program Files\Zoom\bin) and more.

      For Windows, the separator between folders is usually a backslash \, though it will also accept forward-slashes /.

      On Mac and Linux, we use forward-slashes ONLY for the folder separator. Your home folder is at /home/YOURNAME/, and getting elseware builds on top of that. Let's say you have a "homework.txt" file on your Desktop, the path would be /home/YOURNAME/Desktop/homework.txt.

      Knowing the path of your files is important so you can locate them later, or find them when you need to upload them to the web.

      On Windows when you're in the File Explorer, the address bar at the top will show the path. If you click in that area, it will turn to text, and you can copy this text, or just see the full path.

      

      Figure 2: A screenshot of the Windows File Explorer, at location C:\SCHOOL\rsingh13-cs200\Week02-Basics\program1_recipeV1, which contains the recipe1.cpp file.

      You can paste the copied path into an "Open File…" dialog box or in another File Explorer window address bar, and after hitting ENTER it will take you to that path quickly.

   4. Additional Resources
      
      • Files & File Systems: Crash Course Computer Science #20

5.1.3. 📚 Intro: The command line

1. Navigating your system with the Terminal
   
   1. What is a terminal? (aka Shell aka Bash)
      

      A Terminal is another way to navigate your computer, but via a Command-Line Interface. We're used to working with Graphical User Interfaces (GUI) in our day-to-day lives, but the Terminal is still available, even on mobile devices, to navigate the system, create, move, copy, and remove folders and files, and to run files.

      The word "Terminal" is generally interchangable with "Shell" or "Bash" these days, though historically a "Terminal" was not the computer itself but a way to remotely connect to one. But… Our machines usually just call the command line the "Terminal". (Windows uses Powershell or Command Line, Mac and Linux tend to use Terminal).

      Some developer software will require the use of the command line, and some developers tools have a CLI (Command-Line-Interface) AND a GUI (Graphical-User-Interface) option. There can be advantages to a CLI over a GUI, even though it might take a little more time to get used to. For instance, you can automate tasks much more easily from the command line vs. the GUI - when I need to send the same code to every student's repository folder, I can write a small script or command to copy/paste to every folder, then do git add/commit/push, instead of having to do everything slowly with the mouse.

   2. Using the terminal
      
      1. Opening the terminal
         
         • Windows: Go to the Start Menu and type in Bash. Open up Git Bash. (There is also Powershell available, which is Microsoft's default terminal, but there are differences in commands it accepts.)
         • Mac: Click teh Launchpad icon in your Dock and type in Terminal to find the application.
         • Linux: Location depends on your distro, usually it is under "System Tools" from the start menu.
      2. pwd - Present Working Directory
         

         From the starting screen of your terminal, we'll start by entering in the command pwd and hitting enter. pwd stands for "Present Working Directory", and will return a path. On Linux and Mac, this tends to be /home/YOURNAME/.

         

         On Windows it will be something like /c/Users/YOURNAME:

         

         For Windows, if you wanted to find this path in your filesystem, just replace "c" with C:. You can use the forward slashes or backslashes, but it will be "auto-corrected" to C:\Users\YOURNAME in the file explorer.

         

      3. ls - LiSt files/folders
         

         The ls (lowercase L and S) command can be used to view what files and folders are in the current directory.

         

      4. cd - Change Directory
         

         The cd command can be used to navigate into or out of a folder. If you see a folder you want to navigate into, use cd FOLDERNAME. You can then use ls to view the files in this new directory:

         

         If you want to go back (or, "up") to the parent folder, you can use .. as the path. The double period means the parent folder:

         

   3. Additional Resources
      
      • Keyboards & Command Line Interfaces: Crash Course Computer Science #22
      • Why Do Command Lines Still Exist? - Techquickie

5.1.4. 📚 Intro: Memory, storage, and data representation

5.2.1. 📚 Intro: main() and C++ programs

1. Computers and binary, humans and C++
   

   Our computer's CPU only understand commands given to it as binary codes - strings of 1's and 0's, like this: Early programmers had to write their software using this machine code, though over time programming languages evolved. When we write source code these days, we write in a human-made, somewhat human-readable text, with specific grammars and rules to it. These source code files are plaintext - they're just simple text that can be opened in a text editor. We will be using VS Code as the editor where we will write our C++ source code.

   

   Files on a computer use an extention to identify what kind of file it is, such as a .jpg for jpeg format images, .mp3 for audio files, .html for website layouts. At minimum, a C++ program requires one file - a .cpp source file. Usually programs are bigger and contain multiple files, like .h header files as well as other .cpp source files. The file that contains the program starting point is usually named main.cpp, though this name is not required.

   Review 1. A C++ source file is plaintext, so it can be opened…

   • ○ Only in MS Word
   • ○ Only in VS Code
   • ○ Only by the compiler
   • ○ In Notepad or other basic text editors

   Review 2. The following file type(s) are valid C++ source code files:

   • □ .cpp
   • □ .c
   • □ .txt
   • □ .h
2. Contents of a starter C++ program
   

   The bare-minimum C++ program looks like this:

   int main()
   {
     // Code goes here
     return 0;
   }
   

   Every C++ program begins at a main() function.

   For now you can take this code for granted but you will understand it more as the class continues. But, some basic info:

   • The int main() is the function that starts our program.
   • The contents of the program must be between the opening curly brace { and the closing curly brace }. This region is known as main()'s codeblock. We will see more codeblocks (with { }) later in the class.
   • The return 0; is where the program ends. 0 is returned for 0 errors.
   • Code we add will go after the { and before the return 0;.

   Additionally, C++ is case sensitive, so capitalization matters. Make sure you write main() in all lower case - Main() and MAIN() won't work!

   Review 3. All C++ programs must have a starting point, and it will always be…

   • ○ The return 0;
   • ○ The main function
   • ○ The #include <iostream>
   • ○ The start function

   Review 4. The space between { and } is known as…

   • ○ a code block
   • ○ a C++ program
   • ○ a return type
   • ○ a compiler
3. Creating a program: Building source code into a program
   

   Remember that your computer expects to read binary 1010101010, and does not understand English or other human languages. When we're ready to run our C++ program, we need to run it through a program called a compiler.

   A compiler goes through your source code, generating binary code based on what you wrote. The end result is an executable file, also known as a binary file. This is the type of program where, if you double-click it on your computer, it will run.

   The compiler program we are using in class is called g++ (or MinGW, which is a Windows port of g++). When we're ready to test out our code, we can open up a terminal in VS Code and enter the command:

   g++ main.cpp
   

   We're telling the g++ compiler program to convert our main.cpp source code file into an executable. By default, it will either generate a.exe (on Windows) or a.out (on Linux/Mac), but we can always rename our program, or we can tell g++ what to name our program in the same step:

   g++ main.cpp -o MyProgram.exe
   

   Once we're ready to run our program, we would then launch it from the terminal like this:

   ./MyProgram.exe
   

   Though at the moment, this program does nothing except exit! :

   Review 5. In order to specify a custom name for your program executable, you need to use which of these flags?

   • ○ -o
   • ○ -g
   • ○ -exe

   Review 6. What is the name of the compiler program we use to turn our source code into an executable file?

   • ○ main.cpp
   • ○ g++
   • ○ -o
   • ○ MyProgram.exe

5.2.2. 📚 Intro: Variables and data types

1. Storing data in variables
   

   

   Variables are named locations where we can store information.

   We use variables in programming as places to temporarily store data so that we can manipulate that data. We can have the user write to it via the keyboard, we can use files to write data to variables, we can do math operations or modify these variables, and we can print* them back out to the screen or a text file. (*Printing here meaning "display on the screen"; not to a printer.)

   When we're writing programs in C++, we need to tell our program what the data type of each variable is, and give each variable a variable name (aka identifier). When a variable is declared, a space in RAM is allocated to that variable and it can store its data there. That data can be manipulated or overwritten later as needed in the program.

   Some examples of things we might store as variables:

   • A student's information:
     • string studentName, the name of a student
     • float studentGpa, the GPA of that student
     • int creditHoursCompleted, the total amount of credit hours the student has completed
     • bool activeStudent, whether the student is an active student or not (e.g., graduated?)
   • A store website's item listing:
     • string name, the name of the product
     • float price, the price of the product
     • int quantity, how much of this product is in stock

   Review 1. When a variable is declared, where is that data stored?

   • ○ CPU
   • ○ Hard drive
   • ○ Graphics card
   • ○ RAM

   Review 2. In order to use a variable in C++ we must specify…

   • ○ what type of data will be stored in it.
   • ○ how much space in RAM we require, in bytes.

   Review 3. True or false: A variable's value can be overwritten.

   • ○ True
   • ○ False
2. Data types
   

   In C++, when we want to create a variable we need to tell the compiler what the data type of the variable is. Data types specify what is stored in the variable (whole numbers? numbers with decimal values? text? true/false values?). Each data type takes up a different amount of space in memory.

   Some of the common data types we'll use are:

   Data type	Values	Size	Example code
   char	single symbols - letters, numbers, anything	1 byte	char currency = '$';
   boolean	true or false	1 byte	bool savedGame = false;
   integer	whole numbers	4 bytes	int age = 100;
   float	numbers w/ decimals	4 bytes	float price = 9.95;
   double	numbers w/ decimals	8 bytes	double price = 1.95;
   string	any text, numbers, symbols, any length	4 bytes	string password = "123secure";

   • Floats and doubles both store numbers with fractional (decimal) parts, but a double takes up double the memory in RAM, allowing to store more accurate fractional amounts. A float has 6 to 9 digits of precision and a double has 15 to 18 digits of precision. (From https://www.learncpp.com/cpp-tutorial/floating-point-numbers/)
   • Boolean data types store true and false values, but will also accept integer values when assigned. It will convert a value of 0 to false and any other number to true.
   • String variables' values must be written within double quotes "Hello!"
   • Character variables' values must be written within single quotes 'Z'

   Additional information: Unsigned data types

   Sometimes it doesn't make sense to store negative values in a variable - such as speed (which isn't directional, like velocity), the size of a list (can't have negative items), or measurement (can't have negative width). You can mark a variable as unsigned to essentially double its range (by getting rid of the negative side of values). For instance, a normal int can store values from -2,147,483,648 to 2,147,483,647, but if you mark it as unsigned, then your range is 0 to 4,294,967,295.

   Review 4. Identify which data types would work best for each variable description

   Types: float, int, string, char

   Variables:

   prices	temperature	letterGrade	seatsAvailable
   howManyRegistered	names	addresses

3. Declaring variables and assigning values to variables
   
   1. Variable declaration
      

      When we're declaring a variable, it needs to follow one of these formats:

      Declaration forms

      • DATATYPE VARIABLENAME;
      • DATATYPE VARIABLENAME = VALUE;
      • DATATYPE VAR1, VAR2, VAR3;
      • DATATYPE VAR1 = VALUE1, VAR2 = VALUE2;
      • DATATYPE VARIABLENAME{VALUE}; - Newer versions of C++

      The data type goes first, then the variable name/identifier, and if you'd like, you can also assign a value during the same step (though this is not required). Once a variable has been declared, you don't need to declare it again. This means you don't need to re-specify its data type when you're using it. Just address the variable by its name, and that's all.

      Listing 1: Code that uses integers to figure out how many candies each kid should get.

      // Declaring variables and assigning values
      int totalCandies{10};
      int totalKids{5};
      int candiesPerKid{totalCandies / totalKids};
      
      // Reusing the same variables later on
      totalCandies = 100;
      totalKids = 10;
      candiesPerKid = totalCandies / totalKids;
      

      Listing 2: Code to display the price plus tax to the user.

      float price = 9.99;
      float tax = 0.11;
      // Text output to the screen. Can do math within!
      cout << "Please pay " << (price + price * tax);
      

      Additional information: Modern C++: auto

      In C++11 (from 2011) and later, you can use the keyword auto as the "data type" in your variable declaration that includes an assignment statement. When you use auto, it uses the assigned value to automatically figure out the variable's data type, so you don't have to explicitly define it:

      Listing 3: Usage of auto keyword in modern C++.

      auto price = 9.99;      // it's a double!
      auto price2 = 2.95f;    // it's a float!
      auto player = '@';      // it's a char!
      auto amount = 20;       // it's an int!
      

   2. Variable assignment
      

      Assignment forms

      • Stores the LITERAL value in VARIABLENAME:

        VARIABLENAME = LITERAL;

      • Copies the value from VARIABLENAME2 to VARIABLENAME1.:

        VARIABLENAME1 = VARIABLENAME2;

      When assigning a value to a variable, the variable being assigned to always goes on the left-hand side ("LHS") of the equal sign =. The = sign is known here as the assignment operator.

      The item on the right-hand side ("RHS") will be the value stored in the variable specified on the LHS. This can be a literal (a hard-coded value) or it can be a different variable of the same data type, whose value you want to copy over.

      Listing 4: Assigning literal values to variables.

      price = 9.99;       // 9.99 is a float literal
      state = "Kansas";   // "Kansas" is a string literal
      operation = '+';    // '+' is a char literal
      

      Listing 5: Copying student3's value to the bestStudent variable.

      // Declare and initialize our variables
      string student1 = "Hikaru";
      string student2 = "Umi";
      string student3 = "Fuu";
      string bestStudent;
      
      // Assignment statement
      bestStudent = student3;
      

      

   3. Variable copying
      

      If you use two variables in an assignment statement, like this:

      bestStudent = myName;
      

      This will copy the value in myName and store that copy in bestStudent.

   4. Variable initialization
      

      When we declare a variable and give it a value in the same line of code, that is called initialization. The equal sign can be used in this regard:

      string productName = "Candybar";
      float productPrice = 3.25;
      

      But with more modern C++, it's recommended that we use braced initialization:

      string productName{ "Candybar" };
      float productPrice{ 3.25 };
      

      You might see both of these ways used to initialize variables in starter code.

   5. Additional information: Garbage!
      

      If a variable is not initialized with some value, it will have some garbage value assigned to it - whatever was left over in the memory space where it was created. This data isn't useful to us, and usually shows up as random large numbers (12734827), so it's good to make sure to initialize your variables!

      Review 5. How would we declare a variable to represent a person's temperature and give it a value of 98.6?

      Review 6. How would we declare a variable to represent a student's name and assign it the value of Maryam?

      Review 7. What data t ype will the compiler set this variable as?

      • ○ bool
      • ○ char
      • ○ float
      • ○ string

      Review 8. A boolean variable has already been declared and it is named savedGame. How do you assign a value of true to the variable?

      Review 9. Given the two variables declared…

      string user1 = "Bob";
      strin guser2 = "Ami";
      

      And then this assignment statement is executed: user1 = user2;

      What will the value of each variable be afterwrard?

      • user1 is _.
      • user2 is _.
4. Named constants
   

   

   Whenever you find yourself using a literal value in your assignment statements, you may want to think about whether you should replace it with a named constant instead.

   const CONSTNAME = LITERAL;
   

   A named constant looks like a variable when you declare it, but it also has the keyword const - meaning that the value can't change after its declaration.

   Let's say you wrote a program and hard-coded the tax rate:

   // Somewhere in the code...
   totalPrice = cartTotal + ( cartTotal * 0.0948 );
   
   // Somewhere else in the code...
   cout << 0.0948 << " sales tax" << endl;
   

   Then the tax rate changes later on. You would have to go into your program and search for "0.0948" and update all those places! Instead, it would have been easier to assign the tax rate ONCE to a named constant and referred to that instead:

   // Beginning of program somewhere...
   const SALES_TAX = 0.0948;
   
   // Somewhere in the code...
   totalPrice = cartTotal + (cartTotal * SALES_TAX);
   
   // Somewhere else in the code...
   cout << SALES_TAX << " sales tax" << endl;
   

   If you ever find yourself using the same literal multiple times in your program, then perhaps consider replacing it with a named constant.

   Review 10. How would we declare a named constant to represent the maximum amount of students in a class and assign it a value of 30?

5. Naming conventions
   

   

   While you can generally name a variable whatever you'd like, you still need to adhere to the syntax rules of the C++ language. In particular:

   • Names can only contain letters (upper- and lower-case), numbers, and underscores.
   • Spaces are not allowed in a variable name!
   • Names cannot start with a number.
   • A name cannot be a keyword in C++, a name reserved for something else in the language, such as void, if, int, etc.

   There are also naming conventions used so that variables (and later on functions and structs/classes) have a consistent naming scheme:

   • Variables:
     • One common style is lowerFirstLetterThenUpperCase for variable names - this is called Camel Case.
     • Another style you might see in C++ code is all_lower_with_underscores.
     • You might see both of these styles in my starter code or examples, but I try to stick to one style for a program. You should also choose one and stay consistent in each program.
   • Named constants:
     • It is customary to give your named constants names in ALL CAPS, using underscores (_) to separate words. For example: TOTAL_STUDENTS, OP_TAX_RATE, etc.

   Everything in C++ is case sensitive, which means if you name a variable username, it will be a different variable from one named userName (or if you type "userName" when the variable is called "username," the compiler will complain at you because it doesn't know what you mean).

   Review 11. Identify which variable names are valid or invalid.

   • ○ Valid / ○ Invalid total Pizzas
   • ○ Valid / ○ Invalid int
   • ○ Valid / ○ Invalid farmName
   • ○ Valid / ○ Invalid my_int
6. Basic operations on variables
   

   Now that you have variables available in your program to play with, what can you even do with them?

   1. Outputting variable values
      

      Using the cout (character-out) statement, you can display text to the screen with string literals:

      cout << "Hello, world!" << endl;
      

      But you can also display the values stored within variables, simply by using the variable's name:

      cout << myUsername << endl;
      

      You can also chain as many literals, variables, and commands together as long as they have the output stream operator << in-between.

      Listing 6: Displaying multiple string literals and variable values in one cout statement.

      cout << "Student: " << name
           << endl << "GPA: " << gpa
           << endl << "Year: " << year << endl << endl;
      

   2. Inputting variable values
      

      We can use the cin (character-in) statement to get the user to enter something on the keyboard and store that data into a variable:

      float gpa;
      cin >> gpa;
      

      cin >> can be used on strings, but it will not read anything after a space. Instead, we use the getline function to read whole lines of text into string variables:

      string oneLine;
      getline( cin, oneLine );
      
      string oneWord;
      cin >> oneWord;
      

      There will be more information on input and output in a later section.

   3. Math operations
      

      

      With variables with numeric data types (ints, floats, doubles), we can do arithmetic with the +, -, *, and / operators.

      Symbol	Description
      +	Addition
      -	Subtraction
      *	Multiplication
      /	Division

      Make sure to put the result somewhere! When you do a math operation and you want to use the result elsewhere in the program, make sure you're storing the result in a variable via an assignment statement! If you just do this, nothing will happen:

      totalCats + 1;
      

      You can use an assignment statement to store the result in a new variable:

      newCatTotal = totalCats + 1;
      

      Or overwrite the variable you're working with:

      totalCats = totalCats + 1;
      

      

   4. Compound operations
      

      There are also shortcut operations you can use to quickly do some math and overwrite the original variable. This works with each of the arithmetic operations:

      // Long way:
      totalCats = totalCats + 5;
      
      // Compound operation:
      totalCats += 5;
      

      Other shorthand:

      Description	Long version	Short 1	Short 2
      Increment	x = x + 1;	x += 1;	x++; OR ++x;
      Increment	x = x + 2;	x += 2;
      Decrement	x = x - 1;	x -= 1;	x–; OR –x;
      Decrement	x = x - 2;	x -= 2;
      Multiply	x = x * 2;	x *= 2;
      Divide	x = x / 2;	x /= 2;

   5. String operations
      

      Strings have some special operations you can do on them. You can also see a list of functions supported by strings here: C++ String Reference (We will cover more with strings in a later part).

      Concatenating strings

      You can use the + symbol to combine strings together. When used in this context, the + sign is called the concatenation operator.

      string type = "pepperoni";
      string food = "pizza";
      
      // Creates the string "pepperoni pizza"
      string order = type + " " + food;
      

      Letter-of-the-string

      You can also use the subscript operator [ ] (more on this when we cover arrays) to access a letter at some position in the string. Note that in C++, the position starts at 0, not 1.

      string food = "pizza";
      
      char letter1 = food[0];  // Stores 'p'
      char letter2 = food[1];  // Stores 'i'
      char letter3 = food[2];  // Stores 'z'
      char letter4 = food[3];  // Stores 'z'
      char letter5 = food[4];  // Stores 'a'
      

      Review 12. Given the variables x = 4 and y = 2, after the statement z = x + y;

      The value of z will be: _

      Review 13. Given these variables and their values:

      int a = 10;
      int b = 20;
      int c = 30;
      int d = 40;
      

      What is the result of the variable after each of the following operations?

      • a will be _ after:

        a++;
        

      • b will be _ after:

        b--;
        

      • c will be _ after:

        c *= 2;
        

      • d will be _ after:

        d /= 2;
        

      Review 15. A float variable named ratio has already been declared. Which of the following assigns a float literal as a value for the variable?

      • ○ ratio = Calculate( grade, total );
      • ○ ratio = grade / total;
      • ○ ratio = 0.5;
      • ○ ratio = ratio + 1.0;

5.2.3. 📚 Intro: cout - Character output

1. The iostream library
   

   

   A library is a set of prewritten code that we can use in our programs. C++ has a set of libraries that come with it, and third parties can also create libraries. But anyway, in order to be able to display output to the screen we will need to include one of the built-in C++ libraries - iostream.

   At the top of our source code file, we will have to add an #include statement to add this library to our program:

   #include <iostream>
   

   This will allow us to use the cout and endl commands from the std (STandarD) library:

   std::cout << "HI!" << std::endl;
   

   But we can also simplify our code by adding in using namespace std; beneath our library includes, so that we don't have to prefix std:: on all of our iostream commands:

   #include <iostream>
   using namespace std;
   int main()
   {
       cout << "HI!" << endl;
       return 0;
   }
   

   Review 1. If our file begins with just this:

   #include <iostream>
   

   then our outputs will be written like…

   ○ cout << "Hello!";

   ○ std::cout << "Hello!";

   Review 2. If our file begins with this:

   #include <iostream>
   using namespace std;
   

   then our outputs will be written like…

   ○ cout << "Hello!";

   ○ std::cout << "Hello!";

2. Outputting Information with cout
   

   

   In order to display text to the screen with our program, we need to include a library. A library is a set of pre-written code that can be used across multiple programs. C++ contains a standard library of pre-written code we can use. To gain access to the cout (character-output) statement, we need to add this at the top of our C++ program file:

   #include <iostream>
   

   After that, we can use the cout command to display text like this:

   std::cout << "Hello!";
   

   The std:: prefix stands for "STandarD", as in the C++ standard library. This command will display "Hello!" to the screen when the program is built and run.

   You can also add empty lines to the program using the endl (end-line) command:

   std::cout << std::endl;
   

   And these commands can be chained together:

   std::cout << "Hello!" << std::endl << "World!" << std::endl;
   

   The << sign is known as the output stream operator.

   Review 7. A library is…

   • ○ The program that turns C++ code into an exe file.
   • ○ pre-written code we can use in multiple programs.
   • ○ Code we have to write before working on the full program.
   1. Using namespace std
      

      You can put using namespace std; at the top of the C++ program to state that this code file will be using commands out of the std (standard) library. With this, you can remove the std:: prefixes from iostream commands like cout and endl.

   2. Chaining outputs
      

      The cout command (pronounced as "c-out" for "character-out") is used to write information to the screen. This can include outputting a string literal:

      cout << "Hello, world!" << endl;
      

      or a variable's value:

      cout << yourName << endl;
      

      or stringing multiple things together:

      cout << "Hello, " << yourName << "!" << endl;
      

      In C++, we use the output stream operator << to string together multiple items for our output.

   3. Newlines with endl
      

      The endl command stands for "end-line" and ensures there is a vertical space between that cout statement and the next one. For example, if we write two cout statements without endl like this:

      cout << "Hello";
      cout << "World";
      

      Program output:

      HelloWorld
      

      If we want to separate them on two different lines, we can write:

      cout << "Hello" << endl;
      cout << "World";
      

      Program output:

      Hello
      World
      

      Remember that in C++, a statement ends with a semicolon ;, so you can split your cout statement across multiple lines, as long as you're chaining items together with << and only adding a ; on the last line:

      cout << "Name:   " << name
           << "Age:    " << age
           << "State:  " << state << endl;
      

      Review 8. Match the terms to the code…

      1. Character output		A. endl
      2. End line		B. <<
      3. Output stream operator		C. cout

      Review 3. A string literal is…

      ○ Any string variables being declared

      ○ Any text written inside of double quotes

      ○ Any << statements

      ○ The cout command

      Review 4. cout is pronounced "Kowt".

      ○ true

      ○ false

      Review 5. The output stream operator is:

      ○ cout

      ○ endl

      ○ <<

      Review 6. We want to display the message "ERROR: File not found!" to the screen. How do we do this?

      ○ cout << "ERROR: " File not found!;

      ○ cout << ERROR: File not found!;

      ○ cout << "ERROR: File not found!";

      ○ cout << 'Error: File not found!';

      Review 7. A variable has been declared: int year = 1999;.

      How do we display the variable's value to the screen?

      ○ cout << "year";

      ○ cout << 'year';

      ○ cout << year;

3. Good user interfaces
   

   

   One of the important parts of writing software is making sure users know how to navigate and use your program. While writing your programs, assume that the person running it knows nothing about this program. Make sure everything they need to know about the program is given to them as instructions, and make sure menus are easy to read.

   1. Drawing a line of characters across the screen
      

      We can use the string library to create a line of characters with some width, without having to type out all those characters ourselves. Its form looks like this:

      cout << string( AMOUNT, CHAR ) << endl;
      

      An example of it being used is:

      cout << "MAIN MENU" << endl << string( 20, '-' ) << endl;
      

      Program output:

      MAIN MENU
      --------------------
      

   2. Escape Sequences
      

      There are special characters, called escape sequences, that you can use in your cout statements:

      Character	Description
      \n	newline (equivalent to endl)
      \t	tab
      \"	double quote

      cout << "\"hello\nworld\"" << endl;
      

      Program output:

      "hello
      world"
      

      C++ source: Using the tab character in outputs

      cout << "A\tB\tC" << endl;
      cout << "1\t2\t3" << endl;
      

      Program output:

      A       B       C
      1       2       3
      

      C++ source: Displaying text with double quotes in it

      cout << "He said \"Hi!\" to me!" << endl;
      

      Program output:

      He said "Hi!" to me!
      

   3. Formatting currency
      

      By default, the following code:

      float price = 10.90;
      cout << "Price: $" << price << endl;
      

      Will give us output like this:

      Price: $10.9
      

      To get our program to always display two numbers to the right of the decimal place, we need to include the iomanip (input/output manipulation) library:

      #include <iomanip>
      

      And then add this command to our program somewhere:

      cout << fixed << setprecision( 2 );
      

      Then, our program's output will look like this:

      Price: $10.90
      

      1. Tables and columns
         

         

         Figure 3: A simple table in a command line C++ program. There are three columns: ID, Student, and GPA, with the column headers shown on top.

         If we want to make a table in our program, we need to use columns with fixed widths. We will need to #include <iomanip> again.

         We can specify the width of a column for the following item being displayed with the setw command, like this:

         cout << setw( 5 ) << "ID";
         

         This will give the following column a width of 5. The text "ID" takes up 2 spaces, so then there are 3 empty spaces left over. cout statements afterwards will start at the end of this column.

         For a table header, I usually write it like this:

         cout << left
           << setw( 5 ) << "ID"
           << setw( 20 ) << "STUDENT"
           << setw( 6 ) << "GPA"
           << endl << string( 40, '-' ) << endl;
         

         This sets the text alignment to left-aligned (default is right-aligned), then creates three columns: ID, Student, and GPA.

         Then, further down in the table, I can use the same setw values for the data:

         cout
           << setw( 5 ) << "2"
           << setw( 20 ) << "Usagi Tsukino"
           << setw( 6 ) << "2.8"
           << endl;
         

         This will create a nice table that is easy for the user to read.

         Review 8. Let's say we have a variable named currentBalance, which stores a user's bank account balance. What would be a good user interface for displaying the balance to the user?

         ○ cout << Balance: $ << currentBalance << endl;

         ○ cout << currentBalance << endl;

         ○ cout << "Balance: $" << currentBalance << endl;

         ○ cout << "Balance: $" << endl;

         Review 9. Before getting input from the user, you should…

         ○ Display the current value of the variable.

         ○ Display a message using cout to tell the user what kind of input the program is expecting.

         ○ Not display any messages with cout.

         Review 10. To draw a horizontal bar 80 characters wide, you would use…

         ○ cout << string( 80, '-' ) << endl;

         ○ cout << string( '-', 80 ) << endl;

         ○ cout << string( 80, "--" ) << endl;

         ○ cout << string( "--", 80 ) << endl;

         Review 11. Given the program output:

         Hello world! Goodbye world!

         Which line of code contains the tab character \t?

         ○ The line with "Hello world" contains the tab character.

         ○ The line with "Goodbye world" contains the tab character.

         Review 12. Given the program output…

         a

         b

         c

         Which cout statement would match this format?

         ○ cout << "a\tb\tc" << endl;

         ○ cout << "a\nb\nc" << endl;

         ○ cout << "a b c" << endl;

         Review 13. If we had the variable pi = 3.14159 and we wanted to display three digits after the decimal point, we would set…

         cout << fixed << setprecision( _ _ _ _ );

         Review 14. If we want to make the next column take up 10 spaces and display the value of the variable price, we would write…:

         cout << setw( _ _ _ _ ) << price << endl;

5.2.4. 📚 Intro: cin - Character input

1. Using cin >> for variables
   

   When we want the user to enter a value for a variable using the keyboard, we use the cin command (pronounced as "c-in" or "character-in").

   Example: Reading input into one variable

   cin >> VARIABLENAME;
   

   You can also chain cin statements together to read multiple values for multiple variables:

   Example: Inputting data into multiple variables at once (separated by spaces)

   cin >> VARIABLENAME1 >> VARIABLENAME2 >> ETC;
   

   1. Strings and cin >>
      

      When using cin >> with a string variable, keep in mind that it will only read until the first whitespace character, meaning it can't capture spaces or tabs. For example:

      Example: Getting one word (ends at spaces) with the input stream operator

      string name;
      cin >> name;
      

      If you enter "Rachel Singh", name will contain "Rachel". To capture spaces, you need to use a different function.

      Review 1.

      • cout is pronouned ○ kowt / ○ see-out / ○ count
      • cin is pronounced ○ sin / ○ see-in / ○ kin

      Review 2. Given an integer variable declared named totalCookies, how would you get input from the keyboard and store it in this variable?

2. Using getline(cin, var); for Strings
   

   You can use the getline function to capture an entire line of text as a string. This is useful when you want to capture spaces and multiple words. For example:

   Example: Getting a full line of text (including spaces) with the getline function

   string name;
   getline(cin, name);
   

   Review 3. A string variable named currentCourse has been declared. How would we read keyboard input (including spaces) and store it in this variable?

   cout << "Please enter course: ";
   // Then what?
   
   

3. Mixing cin >> var; and getline(cin, var);
   

   If you mix cin >> var; and getline(cin, var);, you might encounter issues with the input buffer. To avoid this, use cin.ignore(); before getline(cin, var); if you used cin >> var; before it.

   int number;
   string text;
   
   cin >> number;
   cin.ignore();
   getline( cin, text );
   

   Review 3. Which of the following scenarios requires the cin.ignore() statement?

   A.

   cin >> var1;
   cin.ignore();
   cin >> var2;
   

   B.

   cin >> var1;
   cin.ignore();
   getline( cin, var2 );
   

   C.

   getline( cin, var2 );
   cin.ignore();
   cin >> var1;
   

   D.

   getline( cin, var1 );
   cin.ignore();
   getline( cin, var2 );
   

5.2.5. 📚 Intro: Program arguments

1. What are program arguments?
   

   Some command line programs take in arguments when you run them. For example: ping yahoo.com . The ping program takes in a URL as an argument, then the program will launch and attempt to send packets of information to the URL and see if there's a response.

   We can also write comamnd line programs with arguments. To do this, we need to add a couple of arguments to main:

   int main( int argCount, char* args[] )
   {
   }
   

   In this case, any text given after the program name will be stored in args[1] and after (the program name is in args[0].) char* args[] is an array of c-style strings, though we can convert them into other data types. The int argCount tells us how many arguments were passed into the program. If the user doesn't pass in enough arguments, we could display an error message and what we expect the arguments to be.

   For the time being, don't worry about "int", "char*", or "[ ]", but we will learn about these later. The arguments item is essentially a list of input items passed to the program. argCount will also contain the amount of arguments passed in. So, if a program is run like this:

   ./program ONE two THREE
   

   Then it would have 4 total arguments (the program name counts as one), with "ONE" being argument #1, "two" being argument #2, and "THREE" being argument #3.

   Review 1. Program arguments…

   • ○ Are a way for data to be passed into a program before it begins running.
   • ○ Are a way to return data from a program once it's done running.
   • ○ Are required in order to compile our C++ source code into an executable file.

   Review 2. Let's say a program named factorial is run like this: ./factorial 5

   Identify each argument

   • A. factorial is argument # _
   • B. 5 is argument # _

   Review 3. Let's say a program named add is run like this: ./add 2 3

   Identify each argument

   • A. add is argument # _
   • B. 2 is argument # _
   • C. 3 is argument # _
2. Converting arguments to different types
   

   We can convert the arguments to different data types. The following code snippet shows examples:

   int main( int argCount, char* args[] )
   {
       if ( argCount < 5 )
       {
           cerr << "Not enough arguments!" << endl;
           return 1;
       }
   
       int myInteger = stoi( args[1] );
       float myFloat = stof( args[2] );
       string myString = string( args[3] );
       char myChar = args[4][0];
   }
   

   Generally in the starter code I'll handle checking for enough arguments and set up the input variables and cast the arguments to them, so you won't have to worry about this part of a program's setup.

   Review 4. Identify the commands used.

   • A. To convert a C-String to an integer we use _.
   • B. To convert a C-String to a float we use _.
   • C. To convert a C-String to a C++ string we use _.

5.2.6. 🧑‍🏫 Example code: main(), variables, cin, cout

5.2.7. 💾 Lab: Programs and variables

5.3.1. 📚 Intro: Boolean logic

1. Introduction
   

   Computers are all about binary - 1's and 0's, on and off, true and false. A large part of writing logic with our programs is all about asking "yes/no" questions. If "criteria" is true, then execute this code… if it's false, execute that code. In order to better understand how branching works in our programs, it's important to learn about boolean logic.

   "Boolean" refers to something that is either true or false. This can be the values "true" and "false" itself, or it can be an expression that evaluates to true or false. For example:

   • if (the user clicked "save") then…
   • if (the account balance is less than 0) then…
   • if (the "done" variable is set to true) then…

   The statements within the parentheses are the boolean expressions, and then we can use those expressions in if statements and while loops to execute code only if that condition evaluates to true.

   Review 1. Which of the following statements are boolean expressions?

   • □ What color is the sky?
   • □ The sky is blue.
   • □ How many fingers am I holding up?
   • □ MarioLives is less than 0.
2. True/false questions in programming
   

   Question	Represented as C++ code
   Is x equal to y?	x == y
   Is x not equal to y?	x != y
   Is x greater than y?	x > y
   Is x greater than or equal to y?	x >= y
   Is x less than y?	x < y
   Is x less than or equal to y?	x <= y
   Is x true?	x
   Is x false?	!x

   x and y can be swapped out with different types of data. We can check if two strings of text are equal, or if two numbers are equal. With the bottom two examples, "is x?" and "is not x?" applies for if x is a boolean variable - a variable that is storing a value of either true or false.

   

   if ( i_have_not_been_fed && it_is_6_am ) {
     MakeLotsOfNoise();
   }
   

   Review 2.

   • What is the "is equal to" operator?
   • What is the "less than or equal to" operator?
   • What is the "greater than or equal to" operator?
   • What is the "not equal to" operator?
3. Compound operations with logic operators
   

   We can also create compound boolean expressions from separate boolean expressions using logic operators. Logic operators are AND (&&), OR (||), and NOT (!).

   • Is x == y and x == z?
     • In C++ code: x = y && x = z
     • True if both sub-expressions are true (x==y and x==z).
     • False if one or both sub-expressions are false.

   if ( wantsBeer && isAtLeast21 && likesBeer ) {
       GiveBeer();
   }
   

   • Is x == y or x == z?
     • In C++ code: x = y || x = z
     • True if at least one sub-expression is true.
     • False if both sub-expressions are false.

   if ( isBaby || isSenior || isVet )
   {
       GiveDiscount();
   }
   

   • Is x false?
     • In C++ code: !x
     • True if the sub-expression is false.
     • False is the sub-expression is true.

   // Just checking documentSaved is true
   if ( documentSaved ) {
       Quit();
   }
   
   // Checking if documentSaved is false
   if ( !documentSaved ) {
       Save();
       Quit();
   }
   

   Review 3.

   • What is the AND operator?
   • What is the OR operator?
   • What is the NOT operator?
4. Boolean variables and relational operations
   

   We can have boolean variables that store true or false, and we can then do tests on those values…

   bool quit = false;
   
   // ( pretend there's more code here )
   
   if ( quit ) // If quit is true
   {
       return 0; // exit
   }
   

   But we can also create boolean expressions by utilizing those relational operators to compare two values together.

   float balance;
   cout << "Enter your bank balance: ";
   cin >> balance;
   
   if ( balance < 0 ) // balance < 0 will return true or false
   {
       cout << "OVERDRAWN!" << endl;
   }
   

   These relational operators can also work on strings, where < and > will check alphabetical order (sort of).

   string student1, student2;
   
   cout << "Enter student 1 name: ";
   getline( cin, student1 );
   
   cout << "Enter student 2 name: ";
   getline( cin, student2 );
   
   if ( student1 < student2 )
   {
       cout << "Student 1 goes first" << endl;
   }
   else
   {
       cout << "Student 2 goes first" << endl;
   }
   

   Note that when using < and > with strings or chars, it will compare them based on alphabetical order - if they're both the same case (both uppercase or both lowercase). The code 65 represents 'A', but the code 97 represents 'a', so items will be "sorted" based on these codes.

5. Truth tables
   

   We can use truth tables to help us visualize the logic that we're working with, and to validate if our assumptions are true. Truth tables are for when we have an expression with more than one variable (usually) and want to see the result of using ANDs, ORs, and NOTs to combine them.

   1. Truth table for NOT:
      

      On the top-left of the truth table we will have the boolean variables or expressions written out, and we will write down all its possible states. With just one variable p, we will only have two states: when it's true, or when it's false.

      On the right-hand side (I put after the double lines) will be the result of the expression - in this case, "not-p" \(!p\). The not operation simply takes the value and flips it to the opposite: true \(\to\) false, and false \(\to\) true.

      p	!p
      T	F
      F	T

   2. Truth table for AND:
      

      For a truth table that deals with two variables, p and q, the total amount of states will be 4:

      1. p is true and q is true.
      2. p is true and q is false.
      3. p is false and q is true.
      4. p is false and q is false.

      p	q		p && q
      T	T		T
      T	F		F
      F	T		F
      F	F		F

      This is just a generic truth table. We can replace the values with boolean expressions in C++ to check our logic.

   3. Truth table for OR:
      

      This also deals with 2 variables, \(p\) and \(q\), so 4 total states. If at least one of the two variables are true, then the entire expression is true. An expression with an "or" is only false when all sub-expressions are false.

      p	q	p ‖ q
      T	T	T
      T	F	T
      F	T	T
      F	F	F

   4. Example - AND:
      

      We will only quit the program if the game is saved and the user wants to quit:

      game_saved	want_to_quit	game_saved && want_to_quit
      T	T	T
      T	F	F
      F	T	F
      F	F	F

      The states are:

      1. T: gameSaved is true and wantToQuit is true: Quit the game.
      2. F: gameSaved is true and wantToQuit is false: The user doesn't want to quit; don't quit.
      3. F: gameSaved is false and wantToQuit is true: The user wants to quit but we haven't saved yet; don't quit.
      4. F: gameSaved is false and wantToQuit is false: The user doesn't want to quit and the game hasn't been saved; don't quit.
   5. DeMorgan's Laws
      

      Finally, we need to cover DeMorgan's Laws, which tell us what the opposite of an expression means.

      For example, if we ask the program "is a \(>\) 20?" and the result is false, then what does this imply? If \(a > 20\) is false, then \(a \leq 20\) is true… notice that the opposite of "greater than" is "less than OR equal to"!

      1. Opposite of a && b
         

         a	b	a && b	!( a && b )	!a ‖ !b
         T	T	T	F	F
         T	F	F	T	T
         F	T	F	T	T
         F	F	F	T	T

         If we're asking "is a true and is b true?" together, and the result is false, that means either:

         1. a is false and b is true, or
         2. a is true and b is false, or
         3. a is false and b is false.

         These are the states where the result of a && b is false in the truth table.

         In other words,

         !( a && b ) \(\equiv\) !a ‖ !b

         If \(a\) is false, or \(b\) is false, or both are false, then the result of a && b is false.

      2. Opposite of a ‖ b:
         

         a	b	a ‖ b	!( a ‖ b )	!a && !b
         T	T	T	F	F
         T	F	T	F	F
         F	T	T	F	F
         F	F	F	T	T

         If we're asking "is \(a\) true or \(b\) true?", if the result of that is false that means only one thing:

         1. Both a and b were false.

         This is the only state where the result of a || b is false.

         In other words,

         !( a ‖ b ) \(\equiv\) !a && !b

         a ‖ b is false only if a is false AND b is false.

   6. Example - OR:
      

      If the store has cakes OR ice cream, then suggest it to the user that wants dessert.

      hasCake	hasIcecream	hasCake ‖ hasIceCream
      T	T	T
      T	F	T
      F	T	T
      F	F	F

      The states are:

      1. T: hasCake is true and hasIcecream is true: The store has desserts; suggest it to the user.
      2. T: hasCake is true and hasIcecream is false: The store has cake but no ice cream; suggest it to the user.
      3. T: hasCake is false and hasIcecream is true: The store has no cake but it has ice cream; suggest it to the user.
      4. F: hasCake is false and hasIcecream is false: The store doesn't have cake and it doesn't have ice cream; don't suggest it to the user.

      Review 2.

      • ○
6. Summary
   

   In order to be able to write if statements or while loops, you need to understand how these boolean expressions work. If you're not familiar with these concepts, they can lead to you writing logic errors in your programs, leading to behavior that you didn't want.

5.3.2. 📚 Intro: If statements

1. Yes or no? - If/Else statements
   

   The computer only understands "yes/no" questions - questions that either result in true or false. Based on these outcomes, we can choose to execute one set of code or another.

   Form of an if/else statement:

   // Do things 1
   
   if ( CONDITION )
   {
     // Do things 2-a
   }
   else
   {
     // Do things 2-b
   }
   
   // Do things 3
   

   The else block is executed when the if check fails. If the CONDITION is false, we can use DeMorgan's Laws to figure out what the program's state is during the else.

   NOTE: The else statement NEVER has a CONDITION.

   Example C++ source: Displaying "can't vote" if age is less than 18, or "can vote" otherwise

   cout << "Enter your age: ";
   cin >> age;
   
   if ( age < 18 )
   {
     result = "can't vote";
   }
   else
   {
     result = "can vote";
   }
   
   cout << "Result: " << result << endl;
   

   If the age is less than 18, it will set the result variable to "can't vote". If that boolean expression is false, that means age is \(\geq\) 18, and then it will set the result to "can vote". Finally, either way, it will display "Result: " with the value of the result variable.

   Review 1. Given the if statement:

   if ( studentCount <= maxStudents )
   {
     cout << "You can register for the course!" << endl;
   }
   else
   {
     cout << "Course is full!" << endl;
   }
   

   When is "You can register for the course!" displayed and when is "Course is full!" displayed?

2. Standalone If statement
   

   For a basic if statement, we use the syntax:

   // Do things 1
   
   if ( CONDITION )
   {
     // Do things 2-a
   }
   
   // Do things 3
   

   The CONDITION will be some boolean expression. If the boolean expression result is true, then any code within this if statement's code block (what's between { and }) will get executed. If the result of the expression is false, then the entire if statement's code block is skipped and the program continues.

   Example: C++ source: Displaying "(OVERDRAWN!)" only if the bank balance is less than 0

   cout << "Bank balance: " << balance;
   
   if ( balance < 0 )
   {
     cout << " (OVERDRAWN!)";
   }
   
   cout << " in account #" << accountNumber << endl;
   

   Program output: Output with balance = -50

   Bank balance: -50 (OVERDRAWN!) in account #1234
   

   Program output: Output with balance = 100

   Bank balance: 100 in account #1234
   

   • The special message "OVERDRAWN!" only gets displayed when the balance is less than 0.
   • The following cout that gives the account number is displayed in all cases.

   Review 2. Given the if statement:

   cout << "Bank balance: $" << balance;
   if ( balance < 0 )
   {
     cout << " (OVERDRAWN)" << endl;
   }
   

   When would "Bank balance" be shown to the screen without (OVERDRAWN), and when would the bank balance and overdrawn text be shown?

3. If/Else if/Else statements
   

   In some cases, there will be multiple scenarios we want to search for, each with their own logic. We can add as many else if statements as we want - there must be a starting if statement, and each else if statement will have a condition as well.

   We can also end with a final else statement as a catch-all: if none of the previous if / else if statements are true, then else gets executed instead. However, the else is not required.

   Form of an if/else if/else statement

   // Do things 1
   if ( CONDITION1 )
   {
     // Do things 2-a
   }
   else if ( CONDITION2 )
   {
     // Do things 2-b
   }
   else if ( CONDITION3 )
   {
     // Do things 2-c
   }
   else
   {
     // Do things 2-d
   }
   // Do things 3
   

   Example: Displays a letter grade based on range, 90 and above is an 'A', and so on…

   cout << "Enter grade: ";
   cin >> grade;
   
   if      ( grade >= 90 ) { letterGrade = 'A'; }
   else if ( grade >= 80 ) { letterGrade = 'B'; }
   else if ( grade >= 70 ) { letterGrade = 'C'; }
   else if ( grade >= 60 ) { letterGrade = 'D'; }
   else                    { letterGrade = 'F'; }
   
   cout << "Grade: " << letterGrade << endl;
   

   1. I'm first checking if the grade is 90 or above. If it is, then I know the letter grade is 'A'.
   2. However, if it's false, it will go on and check the next else if statement. At this point, I know that since grade >= 90 was FALSE
   3. that means: grade < 90 is TRUE.
   4. Since the next statement checks if grade >= 80
   5. if this one is TRUE, I know that: grade < 90 AND grade >= 80

   Review 3. Given the if statement:

   if ( grade >= 90 )
   {
     cout << "Grade: A" << endl;
   }
   else if ( grade >= 80 )
   {
     cout << "Grade: B" << endl;
   }
   else if ( grade >= 70 )
   {
     cout << "Grade: C" << endl;
   }
   else
   {
     cout << "You need to retake the course" << endl;
   }
   

   • When is "Grade: A" displayed?
   • When is "Grade: B" displayed?
   • When is "Grade: C" displayed?
   • When is "You need to retake the course" displayed?
4. Nesting if statements
   

   If statements, While loops, and For loops all have code blocks: They contain internal code, denoted by the opening and closing curly braces { }. Within any block of code you can continue adding code. You can add if statements in if statements in if statements, or loops in loops in loops.

   Nesting an if statement within another if statement basically gives you a boolean expression with an AND.

   Example:

   if ( wantsToVote )
   {
     if ( age >= 18 )
     {
       AllowToVote();
     }
   }
   

   Equivalent logic:

   if ( wantsToVote && age >= 18 )
   {
     AllowToVote();
   }
   

   Whether you implement some logic with nested if statements, or with if / else if statements using AND operations is a matter of design preference- in some cases, one might be cleaner than the other, but not always.

   If you have a statement like this:

   if ( conditionA )
   {
     if ( conditionB )
     {
       Operation1();
     }
     else
     {
       Operation2();
     }
   }
   

   It could be equivalently described like this:

   if ( conditionA && conditionB )
   {
     Operation1();
   }
   else if ( conditionA && !conditionB )
   {
     Operation2();
   }
   

   Review 4. Given this code snippet:

   if ( computerOn == true )
   {
     if ( printerOn == true )
     {
       cout << "RESULT A" << endl;
     }
     else
     {
       cout << "RESULT B" << endl;
     }
   }
   else
   {
     if ( printerOn == true )
     {
       cout << "RESULT C" << endl;
     }
     else
     {
       cout << "RESULT D" << endl;
     }
   }
   

   When is each result displayed?

5. Logic operators with if statements
   

   We can also combine multiple conditions together using our logic operators:

   • AND: &&
   • OR: ||
   • NOT: !

   If we have an if statement with two conditions combined with an AND, then the if statement is only executed if all sub-conditions are true:

   if ( CONDITION1 && CONDITION2 )
       DoThingOne(); /* All conditions were true */
   else
       DoThingTwo(); /* One or more conditions were false */
   

   If we have an if statement with two conditions combined with an OR, then the if statement is executed if at least one sub-condition is true:

   if ( CONDITION1 || CONDITION2 )
       DoThingOne(); /* One or more conditions were true */
   else
       DoThingTwo();/* All conditions were false */
   

   Review 5. Given this code snippet:

   if ( choice < 1 || choice > 5 )
   {
     cout << "INVALID INPUT!" << endl;
   }
   else
   {
     cout << "Valid input" << endl;
   }
   

   When would "INVALID INPUT!" be displayed, and when would "Valid input" be displayed?

   Review 6. Given this code snippet:

   if ( choice >= 1 && choice <= 5 )
   {
     cout << "Valid input" << endl;
   }
   else
   {
     cout << "INVALID INPUT!" << endl;
   }
   

   When would "Valid input" be displayed, and when would "INVALID INPUT!" be displayed?

5.3.3. 📚 Intro: Switch statements

1. Another way to branch
   

   Switch statements are a special type of branching mechanism that only checks if the value of a variable is equal to one of several values. Switch statements can be useful when implementing a menu in a program, or something else where you only have a few, finite, discrete options.

   In C++, switch statements only work with primitive data types, like integers and chars - not strings.

   switch ( VARIABLE )
   {
    case VALUE1:
      // Do thing
    break;
   
    case VALUE2:
      // Do thing
    break;
   
    default:
     // Default code
   }
   

   With a switch statement, each case is one equivalence expression. The default case is executed if none of the previous cases are.

   case VALUE1: // equivalent to: if ( VARIABLE == VALUE1 )
   

   case VALUE2: // equivalent to: if ( VARIABLE == VALUE2 )
   

   break: // required at the end of a case statement (unless...)
   

   default: // equivalent to: else
   

   The default case is not required, just like how the else clause is not required in an if statement.

2. The break; statement
   

   The end of each case should have a break; statement at the end. If the break is not there, then it will continue executing each subsequent case's code until it does hit a break.

   This behavior is "flow-through", and it can be used as a feature if it matches the logic you want to write.

3. Scope: Variables inside cases
   

   If you're declaring a variable within a case statement, you need to enclose your case with curly braces { }, otherwise you'll get compiler errors:

   switch ( operation )
   {
    case 'A':
      {
        float result = num1 + num2;
        cout << "Result: " << result << endl;
      }
     break;
   }
   

4. Calculator example
   

   Perhaps you are implementing a calculator, and want to get an option from the user: (A)dd, (S)ubtract, (M)ultiply, or (D)ivide. You could store their choice in a char variable called operation and then use the switch statement to decide what kind of computation to do:

   switch ( operation )
   {
    case 'A': // if ( operation == 'A' )
     result = num1 + num2;
     break;
   
    case 'S': // else if ( operation == 'S' )
     result = num1 - num2;
     break;
   
    case 'M': // else if ( operation == 'M' )
     result = num1 * num2;
     break;
   
    case 'D': // else if ( operation == 'D' )
     result = num1 / num2;
     break;
   }
   
   cout << "Result: " << result << endl;
   

5. Example: Flow-through
   

   Sometimes you want to check if your variable equals a value "x" or "y", and execute the same code for each. You can use flow-through in this case. If no break; is given for a specific case, then it will continue to execute code for the following case until a break; is found.

   char choice;
   cout << "Do you want to quit? (Y/N): ";
   cin >> choice;
   
   switch ( choice )
   {
    case 'Y':
    case 'y':
     done = true;
     break;
   
   case 'N':
   case 'n':
     done = false;
     break;
   
   default:
     cout << "Unknown selection!" << endl;
   }
   

   Review 1. Given the following code:

   switch( option )
   {
       case 'X':
           cout << "RESULT 1" << endl;
       break;
   
       case 'Y':
           cout << "RESULT 2" << endl;
       break;
   
       case 'Z':
           cout << "RESULT 3" << endl;
       break;
   
       default:
           cout << "RESULT 4" << endl;
   }
   

   And the variable option with the value Y, what will be the output?

   Review 2. Given the following code (no breaks):

   switch( option )
   {
       case 'X':
           cout << "RESULT 1" << endl;
   
       case 'Y':
           cout << "RESULT 2" << endl;
   
       case 'Z':
           cout << "RESULT 3" << endl;
   
       default:
           cout << "RESULT 4" << endl;
   }
   

   And the variable option with the value Y, what will be the output?

5.3.4. 📚 Intro: Structs

1. Introduction to objects
   

   

   Programming paradigms (pronounced "pair-uh-dimes") are ways we can classify different programming styles. Some programming languages support multiple paradigm styles and some are restricted to one style of coding. Over the decades different paradigms have been developed and evolved over time. Object Oriented Programming is one of the most common styles of programming these days, and is a big part of how C++, C#, and Java-based programs are designed.

   1. What are "Objects"?
      

      Defining classes and structs in our programs are a way that we can create our own data types for our variables. When we define our own structures, we can create them with internal variables and functions available to them. The variables we create, whose data types come from a defined class or struct, is known as an object.

      Design-wise, the idea is to take real-world objects and find a way to represent them in a computer program as an object that has attributes (variables) and functionality (functions).

   2. OOP design ideals
      

      The concept of Object Oriented Programming is creating a design that is easy to maintain over time. In particular, there are some core design goals behind OOP, including:

      • Encapsulation: Giving the user / other programmers an “interface” \ to interact with the objects, hiding the inner-workings within the class.
        • Certain functions are made public, which other programmers can use to interface with the object.
        • The other programmers don't need to worry about the inner-workings of the object in order to use it.
        • The developer of the class can modify how the internals work without breaking the public interface.
        • Helps protect the data within the class from being accessed or modified by external things that shouldn't have access to it.
      • Loose coupling: Ideally, different objects in a program shouldn't have their functionality tied to other objects too closely; we want to reduce inter-dependence between objects. When objects are more independent from each other, we say they are loosely coupled.
      • High cohesion: When we design our objects, we shouldn't just throw everything and the kitchen sink into one object. To design an object with high cohesion means that everything inside the object belongs to that object - reduce the clutter.

      Review 1. What does it mean for our objects' designs to be "High Cohesion"?

2. Making our own data type with struct
   

   Structs are a way we can group related information together into one data type.

   For example, let's say we were writing a program for a restaurant, and an item on the menu would have a name, a price, a calorie count, and a "is it vegetarian?" signifier. We could declare these all as separate variables:

   string food1_name;
   float food1_price;
   int food1_calories;
   bool food1_is_veggie;
   

   But there isn't really anything in the program that says these variables are related, except that we as humans have given these variables similar prefixes in their names.

   A better design would be to create a new datatype called MenuItem (or something similar), and the MenuItem will contain these four variables within it. We're basically making a variable data type that can contain multiple variables!

   First we create the struct, which should go in its own .h file:

   Example: MenuItem.h

   struct MenuItem
   {
     string name;
     float price;
     int calories;
     bool isVeggie;
   };
   

   And then we can declare variables of this type in our program:

   Example: Within int main()

   MenuItem food1;
   food1.name = "Bean Burrito";
   food1.price = 1.99;
   food1.calories = 350;
   food1.isVeggie = true;
   
   MenuItem food2;
   food2.name = "Crunchy Taco";
   food2.price = 1.99;
   food2.calories = 170;
   food2.isVeggie = false;
   

   Review 2. Those separate variables with the same prefix to indicate a relationship are (○ beautiful / ○ ugly)

   Review 3. If we were storing multiple food items and using this approach for each, what might be a downside to the design?

   • ○ It's too much typing.
   • ○ Our programs should have no more than 3 variables.
   • ○ There is nothing that requires every food to have the same set of variables.

   Review 4. So, Creating a struct to group like-things together and make a new data type. (○ cool! / ○ terrible!)

3. Best practices: Multiple files in C++ programs
   

   

   When creating a struct, we should create a new source code file in our project. Usually the name of the file will be the same name as the struct, with a .h at the end. This is a header file and declarations for structs (and functions and classes later) will go in these types of files.

   Something you need to require in your .h files that isn't needed for your .cpp files are file guards. These prevent the compiler from reading the file more than once. If it reads it multiple times, it will think you're redeclaring things over and over again. Your .h files should always look like this:

   Example: Struct .h file

   #ifndef _MYFILE_H
   #define _MYFILE_H
   
   // put code here
   
   #endif
   

   Where the "_MYFILE_H" should be changed to something unique in each file - usually, the name of your file.

   Review 5. In standard C++ code, it is better to move our struct declaration to a header (.h) file… (○ true / ○ false)

   Review 6. File guards are needed in .h files because…

   • ○ It makes sure the contents of the .h file don't bleed into your main() function.
   • ○ It protects the file from invaders.
   • ○ It prevents the compiler from reading the same file twice and thinking that there's duplicate code.

   Review 7. A struct can be declared above int main() and the program will still compile and run… (○ true / ○ false)

4. Creating our own structs
   
   1. Declaring a struct
      

      A basic struct declaration is of the form…

      #ifndef _MYFILE_H
      #define _MYFILE_H
      
      struct STRUCTNAME
      {
        // member variables
        int MEMBER1;
        string MEMBER2;
        float MEMBER3;
      };
      
      #endif
      

      Note that the closing curly-brace } must end with a ; otherwise the compiler will give you errors.

      You can name your struct anything you'd please but it has to abide by the C++ naming rules (no spaces, no keywords, can contain letters, numbers, and underscores).

      Any variables we declare within the struct are known as member variables - they are members of that struct.

      Any new variables you declare whose data type is this struct will have its own copy of each of these variables.

   2. Declaring object variables
      

      A object is a type of variable whose data type is a struct (or class). To declare a variable whose data type is a struct, it looks like any normal variable declaration:

      DATATYPE VARIABLE;
      

   3. Accessing member variables
      

      Our struct object variables each have their own member variables, which we access via the dot operator .. We can assign values to it, our read its value, similar to any normal variable.

      VARIABLE.MEMBER1 = 10;
      VARIABLE.MEMBER2 = "ASDF";
      VARIABLE.MEMBER3 = 2.99;
      
      cout << VARIABLE.MEMBER1 << endl;
      

   4. Displaying member variables
      

      When we have a struct declared and an object-variable created…

      Book myBook;
      

      … We won't be able to use cout on the object…

      cout << myBook << endl;
      

      … (Unless we overload operators, but that's for a future class!) Instead, remember that you have to output each member variable in the way you wish, because C++ won't know how you want to display the contents of a struct!…

      cout << "Title:  " << myBook.title << endl
           << "Author: " << myBook.author << endl;
      

      Review 8. What would be an appropriate declaration of a struct meant to represent a vehicle, storing the vehicles's manufacturer and year within?

      Review 9. Given a struct named MenuItem, to declare a variable named food2 of this type, we would write…

      Review 10. If a struct Teacher is declared and an object-variable is created:

      Teacher cs200Teacher;

      Does the following command work?

      cout << cs200Teacher << endl;

      • ○ No, C++ doesn't know how to cout a "Teacher" object we've created.
      • ○ Yes, C++ will automatically recognize the Teacher struct's member variables and display them in order.

      Review 11. If we declared a Course object like: Course cs200;

      How would we assign "cs" to the course department and "200" to the course code?

5. Example: Fraction struct
   

   First we would declare our Fraction struct within Fraction.h:

   #ifndef _FRACTION_H
   #define _FRACTION_H
   
   struct Fraction
   {
     int num;
     int denom;
   };
   
   #endif
   

   Within main(), we could then create Fraction variables and work with them:

   #include "Fraction.h"
   
   int main()
   {
     Fraction frac1, frac2, frac3;
   
     cout << "FIRST FRACTION" << endl;
     cout << "* Enter numerator: ";
     cin >> frac1.num;
     cout << "* Enter denominator: ";
     cin >> frac1.denom;
   
     cout << endl;
     cout << "SECOND FRACTION" << endl;
     cout << "* Enter numerator: ";
     cin >> frac2.num;
     cout << "* Enter denominator: ";
     cin >> frac2.denom;
   
     frac3.num = frac1.num * frac2.num;
     frac3.denom = frac1.denom * frac2.denom;
     cout << endl;
     cout << "PRODUCT: " << frac3.num << "/" << frac3.denom << endl;
   
     return 0;
   }
   

6. Composition: Structs with other Structs as member objects
   

   In addition to creating structs with normal variables, we can also create struct-object-variables as members of another struct.

   Let's say we have a Teacher struct and a Course struct, for each Course we want to store the teacher of that course…

   Teacher.h:

   #ifndef _TEACHER_H
   #define _TEACHER_H
   
   #include <string>
   using namespace std;
   
   struct Teacher
   {
     string name;
     string email;
   };
   
   #endif
   

   Course.h:

   #ifndef _COURSE_H
   #define _COURSE_H
   
   #include "Teacher.h"
   
   #include <string>
   using namespace std;
   
   struct Course
   {
     Teacher teacher;
     string department;
     int code;
     int hours;
   };
   
   #endif
   

5.3.5. 📚 Intro: String library

1. Strings as arrays
   

   

   A string is a special data type that really is just an array of char variables. A string has a lot going on behind-the-scenes, and it also has a set of functions you can use to do some common operations on a string - finding text, getting a letter at some position, and more.

   Note that everything with strings is case-sensitive. A computer considers the letter 'a' and 'A' different, since they are represented by different number codes. Keep that in mind for each of the string's functions.

   Review 1. A char is…

   • ○ Multiple letters, numbers, or symbols, stored in double quotes.
   • ○ Multiple letters, numbers, or symbols, stored in single quotes.
   • ○ A single letter, number, or symbol, stored in double quotes.
   • ○ A single letter, numbe,r or symbol, stored in single quotes.

   Review 2. To a C++ program, the letter 'a' and 'A' are considered…

   • ○ Different characters
   • ○ The same characters
   • Using strings
     

     When we declare a string like this:

     string str = "pizza";
     

     what we have behind-the-scenes is an array like this:

     Value:	'p'	'i'	'z'	'z'	'a'
     Index:	0	1	2	3	4

     Declaring a string actually gives us an array of char variables. We can access the string as a whole by using the string variable's name (str), or access one char at a time by treating str like an array.

   • Subscript operator - get one char with [ ]
     

     We can access each letter of the string directly with the subscript operator, just like an array:

     Example: Outputting each letter of a string

     cout << str[0] << endl; // Outputs p
     cout << str[1] << endl; // Outputs i
     cout << str[2] << endl; // Outputs z
     cout << str[3] << endl; // Outputs z
     cout << str[4] << endl; // Outputs a
     

     Because we can act on a string like an array, this means we can also use a variable to access an arbitrary index of a character in the array…

     Example: Accessing one letter at some position i

     int i;
     cout << "Get which letter? ";
     cin >> i;
     cout << str[i];
     

     Or even iterate over the string with a for loop…

     Example: Iterating and displaying each letter of a string

     for ( int i = 0; i < str.size(); i++ )
     {
         cout << i << " = " << str[i] << endl;
     }
     

     Additionally, strings have a set of functions that we can use to manipulate, search, and otherwise work with them.

     Review 3. Given the variables

     string name = "LUNA";
     char letter;
     

     The first letter of the name is at index 0. How do we store the first letter of name in the char letter variable?

     Review 4. Identify the index of each letter in LUNA:

     Index
     Value	'L'	'U'	'N'	'A'

5.4.1. 📚 Intro: While loops

1. Over and over and over…
   

   A while statement is another type of loop that operates on a CONDITION, similar to a for loop. For loops are better for counting, and while loops are better for conditions.

   A while loop takes this form:

   cout << "Before loop" << endl;
   
   while ( CONDITION )
   {
     // Execute this code
     cout << "Repeats!" << endl;
   }
   
   cout << "After loop" << endl;
   

   Any code within a while loop gets executed while the CONDITION is TRUE. Once the condition is no longer true, then the while loop ends and the program continues.

   Remember that we can build conditional statements with the greater-than, less-than, greater-than-or-equal-to, less-than-or-equal-to, equal-to, and not-equal-to operators.

   Warning! Because a while loop will keep going until the condition is false, it is possible to write a program where the condition never becomes false, resulting in an infinite loop!

   Review 1. The contents of the while loop continue looping…

   • ○ While the condition is true
   • ○ Until the condition is true
   • ○ While the condition is false

   Review 2. Given the following code:

   int age = 0;
   
   while ( age < 18 )
   {
     cout << "Can't vote! Try again next year..." << endl;
     age += 1;
   }
   
   cout << "You're old enough to vote now!" << endl;
   

   When will the loop end?

   • ○ Once the user hits a key
   • ○ The loop will never end
   • ○ Once age is 17
   • ○ Once age is 18

   Review 3. Given the following code:

   char quitProgram = 'n';
   
   while ( quitProgram == 'n' )
   {
     cout << "Do you want to quit? (y/n): " )
     cin >> quitProgram;
   }
   
   cout << "Goodbye!" << endl;
   

   When will the loop end?

   • ○ The loop will never end
   • ○ Once the user types anything besides 'n'
   • ○ Once the user types 'n'
   • ○ When the quit counter reaches 0
2. Relational operators
   

   The Relational Operators are operators where you compare two values or variables. Their names are:

   1. is a equal to b? a == b
   2. is a not equal to b? a != b
   3. is a less than b? a < b
   4. is a less than or equal to b? a <= b
   5. is a greater than b? a > b
   6. is a greater than or equal to b? a >= b

   All of these are basically "yes/no" questions, and can be used to build conditions for if statements and while loops.

   Review 4. Given the following code:

   int choice = 0;
   
   cout << "1. Save" << endl;
   cout << "2. Load" << endl;
   cout << "3. Exit" << endl;
   
   while ( choice != 3 )
   {
     cout << "Choice: ";
     cin >> choice;
   }
   
   cout << "Goodbye" << endl;
   

   When will the loop end?

   • ○ While the choice is less than 3
   • ○ While the choice is greater than 3
   • ○ While the choice is not equal to 3
   • ○ While choice is equal to 3
3. Infinite loops
   

   An infinite loop error can occur if you're using a while loop and nothing inside the loop makes the CONDITION evaluate to FALSE.

   For example, if you run this code, it will keep printing out numbers forever:

   #include <iostream>
   using namespace std;
   
   int main()
   {
     int iterations = 0;
     bool running = true;
   
     while ( running )
     {
       iterations += 1;
       cout << iterations << endl;
     } // end of while loop
   
   
     // never gets to this point
     cout << "THE END" << endl;
     return 0;
   }
   

   There needs to be enough logic inside your while loop to effect the CONDITION. In the example above, we have a running variable, but nothing INSIDE the while loop ever sets it to False. Because it's always true, the loop always keeps running.

   Review 5. Infinite loops are caused by…

   • ○ The loop condition never evaluating to false.
   • ○ The loop condition never evaluating to true.
   • ○ While loops being used where for loops are more appropriate.
4. Logical opposites
   

   If we're asking (x > y)?

   If it's true, then yes, x > y. If it's false, however, then x <= y is true (NOT x < y!). Make sure to keep these in mind…

   1. The OPPOSITE of x > y is x <= y.
   2. The OPPOSITE of x < y is x >= y.
   3. The OPPOSITE of x == y is x != y.

   Review 6. Given the condition (x < 2).

   • The condition will be true when:
   • The condition will be false when:

   Review 7. Given the condition (x > 2).

   • The condition will be true when:
   • The condition will be false when:
5. Uses of while loops
   
   1. Counting up
      

      The following while loop will start at 1, display the number to the screen, and each loop around it will go up by 1 until it gets past 9.

      int num = 1;
      while ( num < 10 )
      {
        cout << num << "\t";
        num++; // add 1 to num
      }
      

      Program output:

      1	2	3	4	5	6	7	8	9
      

   2. Keep the program running
      

      In some cases, you'll have a main menu and want to return the user back to that menu after each operation until they choose to quit. You could implement this with a basic boolean variable:

      bool done = false;
      while ( !done )
      {
        cout << "Option: ";
        cin >> option;
        if ( option == "QUIT" )
        {
          done = true;
        }
      }
      cout << "Bye" << endl;
      

      …OR…

      bool running = true;
      while ( running )
      {
        cout << "Option: ";
        cin >> option;
        if ( option == "QUIT" )
        {
          running = false;
        }
      }
      cout << "Bye" << endl;
      

   3. Validating user input
      

      Sometimes you want to make sure what the user entered is valid before continuing on. If you just used an if statement, it would only check the user's input once, allowing them to enter something invalid the second time. Use a while loop to make sure that the program doesn't move on until it has valid data.

      cout << "Enter a number between 1 and 10: ";
      cin >> num;
      
      while ( num < 1 || num > 10 ) // out of bounds!
      {
        cout << "Invalid number! Try again: ";
        cin >> num;
      }
      
      cout << "Thank you" << endl;
      

      Program output:

      Enter a number between 1 and 10: 100
      Invalid number! Try again: -400
      Invalid number! Try again: -5
      Invalid number! Try again: 5
      Thank you
      

      Review 8. If our program loop is while ( running ), then to quit the loop we set running to what value?

      Review 9. If we say the user must enter a number between 10 and 15, then

      • The invalid cases are:
      • The valid cases are:
6. Do… while loops
   

   A do…while loop is just like a while loop, except the condition goes at the end of the code block, and the code within the code block is always executed at least one time.

   do
   {
     // Do this at least once
   } while ( CONDITION );
   

   For example, you might want to always get user input, but if they enter something invalid you'll repeat that step until they enter something valid.

   do
   {
     cout << "Enter a choice: ";
     cin >> choice;
   } while ( choice > 0 );
   

   Review 10. A

   • ○ while loop
   • ○ do…while loop

   won't even start its inner code-block if the condition is false, but a

   • ○ while loop
   • ○ do…while loop

   will execute its inner code-block at least once.

7. Special commands
   
   1. continue
      

      Sometimes you might want to stop the current iteration of the loop, but you don't want to leave the entire loop. In this case, you can use continue; to skip the rest of the current iteration and move on to the next.

      int counter = 10;
      while ( counter > 0 )
      {
        counter--;
        if ( counter % 2 == 0 ) // is an even number?
        {
          continue; // skip the rest
        }
        cout << counter << " odd number" << endl;
      }
      

      Program output:

      9 odd number
      7 odd number
      5 odd number
      3 odd number
      1 odd number
      

   2. break
      

      In other cases, maybe you want to leave a loop before its condition has become false. You can use a break; statement to force a loop to quit.

      while ( true ) // Infinite loop :o
      {
        cout << "Enter QUIT to quit: ";
        cin >> userInput;
        if ( userInput == "QUIT" )
        {
          break; // stop looping
        }
      }
      

      (Note: This example is considered bad design!)

      Review 11. Let's say we have a loop but a certain value might be invalid. Which command should we use at the // SKIP! line, so that we don't stop the loop but just move on to the next iteration?

      float num = 10;
      
      for ( int i = 5; i >= -5; i-- )
      {
          cout << num << " divided by " << i << " is: ";
      
          if ( i == 0 )
          {
              cout << "(Not valid!)" << endl;
              // SKIP!
          }
      }
      

      • ○ break;
      • ○ continue;
      • ○ return;
      • ○ panic;

5.4.2. 📚 Intro: Casting between data types

5.4.3. 📚 Intro: File I/O

1. Output streams
   

   

   Saving data from our program and out to an external file is an important part of software. While we'll mostly be working with very simple data types like .txt, .csv, or maybe .html, tons of software everywhere extracts its data into all sorts of formats.

   Saving out data can also be useful because the program can load that data in later on, so that each time you run the program all the data and changes made are saved.

   In C++ we've been using cout to stream information to the console window in our programs. Using cout requires including the iostream library.

   cout << "Hello, " << location << "!" << endl;
   

   Writing out to a text file works in a very similar way. We will need to include the fstream library in order to get access to the ofstream (output-file-stream) object. Streaming out to a file works in the same way as with cout, except that we need to declare a ofstream variable and use it t open a text file.

   #include <iostream>             // Console streams
   #include <fstream>              // File streams
   using namespace std;
   
   int main()
   {
     // Console output
     cout << "Hello, world!" << endl;
   
     // File output
     ofstream outputFile( "file.txt" );
     outputFile << "Hello, world!" << endl;
     outputFile.close();
   }
   

   You can use the output stream operator << to continue chaining together different items - endl, string literals in double quotes, variable values, etc. just like with your cout statements.

   Once the file is closed, you will see the file on your computer, usually the same directory as your .cpp files.

   Review 1. We have the variable hour, how would we output it to the console screen?

   • ○ cout << hour;
   • ○ cout >> hour;
   • ○ getline( cout, hour );

   Review 2. What are some types of outputs a program might generate?

   • □ A banana
   • □ A spreadsheet of all the inventory a business has in stock
   • □ A text file log of all chat history between two people.
2. Writing output to files
   

   To write information to the screen first we need to include the file stream library:

   #include <fstream>
   

   Then, we declare a variable of type ofstream (output-file-stream). ofstream is the data type, and you can give it whatever variable name:

   ofstream outputFile;
   

   Sometimes, your program might read multiple files at once, so then you'd declare more than 1 ofstream variable. But for here, we're just working with the one.

   We can then open a file name that we will be writing out to:

   outputFile.open( "save.txt" );
   

   Now we can output text to our file in the same way we use cout, except replacing cout with the outputFile variable…

   outputFile << "Name: " << name << endl;
   

   If you want to close the file manually, use the .close() function:

   outputFile.close();
   

   Otherwise, the ofstream object will close automatically when the program closes or when the function it's declared within exits.

   Review 3. Match the lines of code with the descriptions of what they do.

   CODE SNIPPETS:

   • a. ofstream output
   • b. output.open( "save.txt" );
   • c. output << "Hello World!";
   • d. output.close();

   DESCRIPTIONS: These are out of order, mark which code snippet it describes.

   ○ a / ○ b / ○ c / ○ d	Closes the file currently opened in the output file stream.
   ○ a / ○ b / ○ c / ○ d	Declares an output file stream variable.
   ○ a / ○ b / ○ c / ○ d	Writes text out to the file via the output file stream variable.
   ○ a / ○ b / ○ c / ○ d	Opens a text file to be accessible via the output file stream variable.

   • The path of the output file
     

     

     Figure 4: A folder view of a directory where a text file is located.

     When you've built a program with g++ and are running it as ./program.out or ./program.exe, the path of that exe file is the working directory. This is the default directory where text files will be saved, and the default directory it will look at to try to open files to load.

     You can adjust the path using ../ to go back/up one folder or, if you have a subfolder like a "data" directory, you can use the folder's name FOLDERNAME/file.txt as a path.

     

     Figure 5: A plaintext editor open showing the contents of restaurants.txt, which contains restaurant names, addresses, and prices.

     You can open the text file output with a text editor like notepad or a code editor like VS Code. It's just plaintext!

     Review 4. What is the default read/write path for fstream objects?

     • ○ C:\
     • ○ My Documents
     • ○ Same location as the .exe/.out file
   • Outputting different file types
     

     Many file formats are just plain text files if you open them in Notepad. You can save your program's output to more than just .txt files as well - you could use .csv (comma separated value) files, or .html files, or other file types as well.

     Just name your file a .csv or .html file when using the open function:

     output.open( "data.html" );
     

     And then output text that is formatted as the correct file type:

     output << "<h1>Q1 Data</h1>" << endl;
     output << "<p>This year we found that <strong>potatoes</strong>" << endl;
     output << "solid well, outselling tomatoes.</p>" << endl;
     

     Any file type that is a plaintext file can be built as well - .html files, .csv files, heck, even .cpp files. However, generally if you wanted to write a program to output a different file type, you'd use a library to properly convert the data.

     Example: Outputting HTML data:

     #include <fstream>
     using namespace std;
     
     int main()
     {
       ofstream outputFile( "page.html" );
       outputFile << "<body>" << endl;
       outputFile << "<h1>This is a webpage</h1>" << endl;
       outputFile << "<p>Hello, world!</p>" << endl;
       outputFile << "</body>" << endl;
       outputFile.close();
     }
     

     Example: Outputting CSV data:

     #include <fstream>
     using namespace std;
     
     int main()
     {
       ofstream outputFile( "spreadsheet.csv" );
       outputFile << "COLUMN1,COLUMN2,COLUMN3" << endl;
       outputFile << "cell1,cell2,cell3" << endl; // row 1
       outputFile << "cell1,cell2,cell3" << endl; // row 2
       outputFile << "cell1,cell2,cell3" << endl; // row 3
       outputFile.close();
     }
     

     Review 5. A .csv file is a spreadsheet-like format with rows, columns, and cells of data. What types of data might be good to store as a .csv file, and what would be better as a simple .txt file?

     ○ txt / ○ csv	A course with its name, search code, and credit hours.
     ○ txt / ○ csv	A game character's level, experience, and amount of gold.
     ○ txt / ○ csv	A list of books with their titles, author names, and isbn.
     ○ txt / ○ csv	A receipt for purchasing a product, including tax and final total price

3. Reading documentation
   

   

   Documentation is an important part of software development. People who write code that's used by others need to provide documentation so that others can know how to use the functionality without having to read the source code.

   The C++ ofstream library docs are here:

   https://www.cplusplus.com/reference/fstream/ofstream/

   Under the "Public member functions" header is a list of functions that ofstream provides, and clicking on a function will give you some example code and more information.

   Review 6. The ofstream::open documentation page has an example of the function's form, which looks like this:

   void open (const char* filename,
       ios_base::openmode mode = ios_base::out);
   

   This shows us what inputs the function can take. The filename is the filename we pass to it (e.g., myFile.open( "todo.txt" ); ), and there is an optional mode argument.

   What is the data type of the filename argument?

   • ○ const char*
   • ○ float
   • ○ std::string

   Review 7. In the ofstream::open documentation, the first paragraph of text describes what this function does. What does it do?

   • ○ Closes the file currently associated with the object, disassociating it from the stream.
   • ○ Opens the file identified by argument filename, associating it with the stream object, so that input/output operations are performed on its content. Argument mode specifies the opening mode.
   • ○ Returns whether the stream is currently associated to a file.

   Review 8. In the ios::fail documentation, under Return Value, it describes the possible results of calling this function. What might this function return?

   • ○ a '+' or '-' character
   • ○ a true or false boolean value
   • ○ a negative or positive integer
4. Input streams
   

   

   We can use the ofstream library to write text and data out to text files. In the same family of tools, the ifstream library ("input file stream") allows us to read in files for use in our programs.

   We could save/load save data files, such as in a video game, so you don't lose your process. You could also load in a document to "process" in some way.

   Writing code to read in text is a little harder than just writing something out, because we have to tell our program how to read. Ifstream will bring in words or lines of text for us, but we have to tell our program how to make sense of what it's loaded in. This process is known as parsing.

   File input streams work just line console input streams. You will need to create a ifstream (input-file-stream) object and open a file, and then you can read in the contents of that file. Files to be read should generally be placed in the same path as your .cpp file, though the working directory on your system may vary.

   Example:

   #include <fstream>              // File streams
   #include <string>               // Strings
   using namespace std;
   
   int main()
   {
     string data1, data2;
   
     // File input
     ifstream inputFile( "file.txt" );
     inputFile >> data1;             // Read one word
     inputFile.ignore();             // Clear buffer
     getline( inputFile, data2 );    // Read one line
     inputFile.close();
   }
   

   Just like with using cin, you can use the input stream operator (>>) and the getline() function with the file streams to get text. You will also need one or more variable to store the text read in.

   Review 9. What are some examples of input files a program might read? (Multiple selection)

   • □ A banana
   • □ A configuration file for program options
   • □ Family ancestry data
   • □ The text of an ebook
   • Reading input
     

     We will use the same library to get access to both ofstream and ifstream. Remember "File Stream" is what "fstream" stands for.

     #include <fstream>
     

     Remember that ofstream was the data type of the variable we'd create to open a text file and write data out. For input, we use ifstream, but we still can open a file in the same way:

     ifstream inputFile;
     inputFile.open( "save.txt" );
     

     We can read contents from our input file stream similarly to how we would work with cin for the keyboard input. Reading in one word or piece of data at a time will use the input stream operator >>:

     // Read from text file, save to playerExperience variable.
     inputFile >> playerExperience;
     

     And reading a whole line of text at a time will use getline:

     getline( inputFile, playerName );
     

     We still need to use the ignore() function when moving from a >> statement to a getline statement:

     inputFile >> playerHp;
     inputFile.ignore();
     getline( inputFile, playerName );
     

     And, we can close the file manually if we'd like:

     inputFile.close();
     

     The file itself is read from the left-to-right, top-to-bottom, similar to how you might think of a typewriter working. If we use >>, it will read the left word to the right word, and once it hits the end of a line it will return all the way to the left but one line down. If we use getline, it will start at the top line and move down one line at a time as it reads.

     Review 10. Let's say we saved a "save game" file in this order:

     1. Player name
     2. Player's experience points
     3. Player's gold amount
     

     What order do we load in the data from the file?

     • ○ Gold then Experience then Name
     • ○ Name then Experience then Gold

     Review 11. Match the lines of code with the descriptions of what they do.

     CODE SNIPPETS:

     • a. ifstream input
     • b. input.open( "save.txt" );
     • c. getline( input, var2 );
     • d. input >> var1;

     DESCRIPTIONS: These are out of order, mark which code snippet it describes.

     ○ a / ○ b / ○ c / ○ d	Read a line of text from the input file into a variable.
     ○ a / ○ b / ○ c / ○ d	Declares an inputfile stream variable.
     ○ a / ○ b / ○ c / ○ d	Reads a word of text from the input file into a variable.
     ○ a / ○ b / ○ c / ○ d	Opens a text file to be accessible via the input file stream variable.

   • What if the file isn't found?
     

     When we're saving an file with ofstream we don't really have to worry about if the file already exists or not - if it doesn't exist, a new one will be created.

     For reading a file with ifstream, however, if no file exists to read, then what? Well, we should check to see if opening the file failed, and if it did, perhaps we use some default values instead, or give an error and exit the program.

     To check if the open process failed, we use an if statement:

     ifstream input;
     input.open( "userdata.txt" );
     if ( input.fail() )
     {
       cout << "ERROR: Could not find file!" << endl;
       return 2;
     }
     

     Review 12. When opening an (○ ifstream / ○ ofstream) file

     for (○ loading / ○ saving) we should check to see if the open was successful via the fail() function.

   • Reading an entire file
     

     Reading chunks of data:

     Let's say you have a file full of data to read in. For this example, the file will be a list of numbers that we want to add together. The file might look something like….

     File: Data.txt

     9 15 16 0 10 13 5 16 1 9 2 17 3 3 8
     

     In our program, we want to read all the numbers, but to do this, we need to use a loop and read in one number at a time. We can keep a running total variable to keep adding data to the sum as we go. We can use a loop to continue reading while it is successful, using this as the condition: input >> readNumber. This will stop the loop once there's nothing else to read, and it updates the readNumber variable with the input each cycle.

     Example:

     ifstream input( "data.txt" );
     
     int sum = 0;    // Sum variable
     int readNumber; // Buffer to store what we read in
     
     // Keep reading while it's possible
     while ( input >> readNumber )
       {
         sum += readNumber;  // Add on to the sum
     
         // Output what we did
         cout << "Read number " << readNumber
              << ",\t sum is now " << sum << endl;
       }
     
     cout << "FINAL SUM: " << sum << endl;
     

     File output:

     Read number 9,   sum is now 9
     Read number 15,  sum is now 24
     (... etc ...)
     Read number 3,   sum is now 119
     Read number 8,   sum is now 127
     FINAL SUM: 127
     

     Reading lines of data:

     In other cases, maybe you're reading in text data from a file and want to read in a full line at a time. We can use a while loop with the getline() function as well to make sure we read each line of a text file:

     Example:

     ifstream input( "story.txt" );
     
     string line;
     
     while ( getline( input, line ) )
     {
       cout << line << endl;
     }
     

     File output:

     CHAPTER I.
     Down the Rabbit-Hole
     
     Alice was beginning to get very tired of sitting by her
     sister on the bank, and of having nothing to do: once or
     twice she had peeped into the book her sister was
     reading, but it had no pictures or conversations in it,
     "and what is the use of a book," thought Alice "without
     pictures or conversations?"
     

   • Parsing plaintext files
     

     There are different ways you can design a text file's save format so that you can more easily read it in later on. Let's go over some common techniques. You might also want to take note of these for use in our class projects.

     A plaintext file is a file that just contains text, which can be opened in a program like notepad.

5. Saving and loading data
   

   

   • Parsing files
     

     Reading in data from a file is one thing, but making sense of what was read in is another. Are you storing saved data from the last session of the program? Are you trying to parse data to crunch? How do you read that data in logically?

     First, if your program is going to be saving output that will need to be read in and made sense of later on, how do you organize the data that's output? It's up to you to make sure to structure the output save data in a consistent and readable way.

     Let's say two developers come up with different formats to store a video game save file:

     File: Output save game file (FORMAT 1)

     RachelsGame
     5
     1000
     RegnierCenter
     

     File: Output save game file (FORMAT 2)

     SAVEGAME        RachelsGame
     LEVEL           5
     GOLD            1000
     LOCATION        RegnierCenter
     

     • For FORMAT 1, we would have to make sure to write our program so that it always saves and loads in the specific order: GAME-NAME, LEVEL, GOLD, LOCATION.
     • For FORMAT 2, since labels are added, we could read in a label, then decide whether the next thing to load in is the GAME-NAME, LEVEL, GOLD, or LOCATION. However, the extra information ("SAVEGAME", "LEVEL", "GOLD", "LOCATION") adds extra storage space to savegame file, and that information is mostly just useful to the humans reading it.

     If every save file from the program is formatted in the same way (FORMAT 1), then when reading the file we can make assumptions…

     • First word: Save game name - store in gameFileName.
     • Second word: Player's level - store in level.
     • Third word: Player's gold - store in gold.
     • Fourth word: Player's location - store in location.

     …And so on. This could work, but we could also take advantage of those human-readable labels that were added into the file (FORMAT 2):

     • Read firstWord.
     • If firstWord is "SAVEGAME", then read the next word into gameFileName.
       • Else if firstWord is "LEVEL", then read the next word into level.
       • Else if firstWord is "GOLD", then read the next word into gold.
       • Else if firstWord is "LOCATION", then read the next word into location.

     So, let's say we have our four variables for a save game:

     Name	Data type
     gameFileName	string
     level	int
     gold	int
     location	string

     When we go to save our game file, here is what both formats' save process would look like:

     Example: Saving for FORMAT 1

     // Save the game
     ofstream output( "save.txt" );
     output << gameFileName << endl;
     output << level << endl;
     output << gold << endl;
     output << location << endl;
     

     File output: Saved game file:

     SAVEGAME MyGame
     LEVEL    1
     GOLD     10
     LOCATION OCB
     

     Example: Saving for FORMAT 2

     // Save the game
     ofstream output( "save.txt" );
     output << "SAVEGAME " << gameFileName << endl;
     output << "LEVEL    " << level << endl;
     output << "GOLD     " << gold << endl;
     output << "LOCATION " << location << endl;
     

     File output: Saved game file:

     SAVEGAME MyGame
     LEVEL    1
     GOLD     10
     LOCATION OCB
     

     Now, to load in each format, we would have to take a couple of different approaches.

     Example: Loading for FORMAT 1

     For this format, the savegame data would have to always be in the same order, so we know we also load the data in the same order.

     // Load the game
     string buffer;
     ifstream input( "save.txt" );
     input >> gameFileName;
     input >> level;
     input >> gold;
     input >> location;
     

     Example: Loading for FORMAT 2

     This one has the helper labels so we read in the first word, investigate what it says, and based on that decide which variable we're loading into next.

     string buffer;
     ifstream input( "save.txt" );
     
     while ( input >> buffer )
     {
       if ( buffer == "SAVEGAME" )
         input >> gameFileName;
     
       else if ( buffer == "LEVEL" )
         input >> level;
     
       else if ( buffer == "GOLD" )
         input >> gold;
     
       else if ( buffer == "LOCATION" )
         input >> location;
     }
     

     If we stepped through this, buffer is always going to store one of the data labels, because after buffer is read, we immediately read the second item in the line of text. Once the second item is read, the next thing to be read will be the next label.

     Review 13. Which format would this snippet of code write out?

     // Save the game
     ofstream output( "save.txt" );
     output << gameFileName << endl;
     output << level << endl;
     output << gold << endl;
     output << location << endl;
     

     Review 14. Which format would this snippet of code write out?

     // Save the game
     ofstream output( "save.txt" );
     output << "SAVEGAME " << gameFileName << endl;
     output << "LEVEL    " << level << endl;
     output << "GOLD     " << gold << endl;
     output << "LOCATION " << location << endl;
     

     Review 15. Which format would this snippet of code load in?

     string buffer;
     ifstream input( "save.txt" );
     
     while ( input >> buffer )
     {
       if ( buffer == "SAVEGAME" )
         input >> gameFileName;
     
       else if ( buffer == "LEVEL" )
         input >> level;
     
       else if ( buffer == "GOLD" )
         input >> gold;
     
       else if ( buffer == "LOCATION" )
         input >> location;
     }
     

     Review 16. Which format would this snippet of code load in?

     // Load the game
     string buffer;
     ifstream input( "save.txt" );
     input >> gameFileName;
     input >> level;
     input >> gold;
     input >> location;
     

6. Working with files in the Real World
   

   Usually you would be working with some kind of library that handles serializing data between its file format to models in the program code, or at least handles reading and parsing the data file and provides a format that's easier for you to use to fill in that data model in the program.

   JSON (JavaScript Object Notation) is widely used on the web, especially to transmit data between client (your web browser) and server (a web host).

   

   Figure 6: The Firefox network inspector showing a JSON response from GitLab

   Other common formats are XML, CSV, or even Binary files.

   There are also databases, but those work differently from just storing a plaintext file on your system.

   

   Figure 7: An XML view of the NPR RSS feed.

5.5.1. 📚 Intro: For loops

1. What is a for loop?
   

   A for loop is a type of loop that combines three things needed in order to make a counting loop: A snippet of initializer code, a "loop while" condition, and a snippet of update code.

   With a while loop, we might have to write a counter like this:

   int counter = 0; // initialize
   while ( counter < 10 ) // condition
   {
       cout << counter << endl;
       counter++; // update
   }
   

   But with a for loop, we can boil it down into a simpler form:

   for ( int counter = 0; counter < 10; counter++ )
   {
     cout << counter << endl;
   }
   

2. Form of a for loop
   

   The for loop takes this form:

   for ( INIT; CONDITION; UPDATE )
   

   Technically, any kind of command can go in INIT and UPDATE, though usually INIT is to declare a counter variable and UPDATE is to add or make an update to that counter variable.

   • INIT CODE: This is some code that is executed before the loop starts. This is usually where a counter variable is declared.
   • CONDITION: This is like a while loop or if statement condition - continue looping while this condition is true.
   • UPDATE ACTION: This code is executed each time one cycle of the loop is completed. Usually this code adds 1 to the counter variable.

   Technically you can use the for loop in a lot of ways, but the most common use is something like this:

   Example: Basic for loop

   for ( int i = 0; i < 10; i++ )
   {
     // Do something 10 times
     cout << i << "\t";
   }
   

   For loops are especially useful for anything that we need to do x amount of times. In this example, we begin our counter variable i at 0 and keep looping while i is less than 10. If we cout i each time, we will get this:

   Program output:

   0	1	2	3	4	5	6	7	8	9
   

   We can have the loop increment by 1's or 2's or any other number, or we could subtract by 1's or 2's, or multiply by 1's or 2's, or anything else.

   Example: Count down from 10 to 1 by 1 each time

   // 10 9 8 7 6 5 4 3 2 1
   for ( int i = 10; i > 0; i-- )
   {
     cout << i << "\t";
   }
   

   Example: Count from 0 to 14 by 2's

   //  0 2 4 6 8 10  12  14
   for ( int i = 0; i >= 14; i += 2 )
   {
     cout << i << "\t";
   }
   

   Example: Count from 1 to 100 by doubling the number each time

   // 1  2 4 8 16  32  64
   for ( int i = 0; i >= 100; i *= 2 )
   {
     cout << i << "\t";
   }
   

   For loops will come in even more handy later on once we get to arrays.

3. Nesting loops
   

   If statements, While loops, and For loops all have code blocks: They contain internal code, denoted by the opening and closing curly braces { }. Within any block of code you can continue adding code. You can add if statements in if statements in if statements, or loops in loops in loops.

   Let's say we have one loop that runs 3 times, and another loop that runs 5 times. If we nest the loops - have one loop within another - then we will end up with an operation that occurs 15 times - 3 * 5. Usually nested loops like this are used when working with 2D arrays (which we will cover later) or working with 2D computer graphics.

   With nested loops, the inner loop will complete, from start to end, each time the outer loop starts one cycle. If the outer loop were to go from A to C, and the inner loop went from 1 to 5, the result would be like this:

   A	1	2	3	4	5
   B	1	2	3	4	5
   

   Example nested loop:

   for ( int outer = 0; outer < 3; outer++ ) {
     for ( int inner = 0; inner < 3; inner++ ) {
       cout << "OUTER: " << outer
         << "\t INNER: " << inner << endl;
     }
   }
   

   Program output:

   OUTER: 0	 INNER: 0
   OUTER: 0	 INNER: 1
   OUTER: 0	 INNER: 2
   OUTER: 1	 INNER: 0
   OUTER: 1	 INNER: 1
   OUTER: 1	 INNER: 2
   OUTER: 2	 INNER: 0
   OUTER: 2	 INNER: 1
   OUTER: 2	 INNER: 2
   

   See how each line, the INNER number goes up each time and the OUTER number does NOT go up each time… it only goes up once the INNER loop has completed.

5.5.2. 📚 Intro: Traditional arrays

1. Array basics - what are arrays?
   

   In C++, arrays are a built-in way to store a series of similar data all under one name. Before now, if we wanted to store a list of students in a class (or similar kind of data), we would have to declare a bunch of separate variables and write the same code over and over to manage it:

   Example: Creating separate variables for three students and creating 3 different prompts and inputs for each variable

   string student1, student2, student3;
   
   cout << "Enter student 1 name: ";
   cin >> student1;
   
   cout << "Enter student 2 name: ";
   cin >> student2;
   
   cout << "Enter student 3 name: ";
   cin >> student3;
   

   This would quickly become unmanageable if you were writing a program with tens, hundreds, or thousands of students stored in it. Instead, we can make use of arrays to store a series of related data together.

   Example: Creating an array and asking the user to enter a value for every element of the array

   string students[100];
   for ( int i = 0; i < 100; i++ )
   {
     cout << "Enter student " << (i+1) << " name: ";
     cin >> student[i];
   }
   

   Arrays allow us to operate on the same name (e.g., student), but addressing different elements of the array with an index number. This way, we can write code to act on the data once, just modifying that index to work with different pieces of data.

   Example: student array of size 4:

   Element	Rai	Anuj	Rebekah	Rose
   Index	0	1	2	3

   Each item in the array has a corresponding index marking its position in the list, with 0 being the first value. If an array is of size \(n\), then the valid indices are 0 through \(n-1\).

   An element is the information stored at that index position, which is essentially a single variable in an array of variables.

   Review 1. When we have a list of data to store, it is better to store it as… ○ an array / ○ a bunch of separate variables

2. Using traditional (C-style) arrays
   
   1. Rules of traditional arrays
      

      Array data types

      Arrays can be declared with any data type. To the computer, we are just declaring \(n\) amount of some variable, and it takes care of putting all the n variables back-to-back in memory.

      First index is 0

      Most programming languages (but not all) have 0 as the first index for arrays of items. (In the Lua programming language, we start at 1!)

      Review 2. In C++, arrays begin at index: _

      Review 3. If we have access to indices [0], [1], and [2] in our array, then how many total elements are in the array? _

      Size must be known at compile-time

      Traditional C-style arrays must have its size be defined during its declaration and the array cannot be resized during the program's execution. Because the array size can't change, and because we may need to know the size of the array throughout the program, we will generally use a named constant to store the size of the array.

      const int MAX_STUDENTS = 100;
      string students[MAX_STUDENTS];
      

      Array size (const) vs. item count (variable)

      Because an array's size cannot be changed after its declaration, it often becomes necessary to overshoot the amount of spaces we need in the array so that we always have enough room for our data. Perhaps a school's classrooms range from 20 to 70 seats, so we would want to declare the array of the biggest size so that we don't run out of space. Because of this, not all spaces in the array may be taken up at any given time.

      C++ doesn't have a function to directly get the amount of elements in an array, so generally when declaring an array we need to also have an associated variable to track how many items we've stored in the array.

      Example: Declaring an array, storing a value for the element at index 0, adding 1 to the item count

      const int MAX_STUDENTS = 100;   // total array size
      int studentCount = 0;           // how many elements
      string students[MAX_STUDENTS];  // array declaration
      
      students[0] = "Rai";            // setting up first student
      studentCount++;                 // adding 1 to student count
      

      Review 4. If you're working with a traditional array, best practice is to store its size in a…

      • ○ integer variable /
      • ○ named int constant
   2. Array declaration
      

      In C++, we declare an array similarly to how we declare a variable, except that we need to specify an array size during declaration:

      Example: Declaring an array of strings of size 100

      // An array of size 100
      string students[100];
      

      Or, if we already have data to put into it, we can initialize it with an initializer list. Then the array will be sized at however many items you give it.

      Example: Declaring an array of strings, initializing the data with an initializer list

      // An array of size 4
      string students[] = {"Rai", "Anuj", "Rebekah", "Rose"};
      

   3. Accessing elements of an array
      

      Valid indices

      As stated earlier, if an array is of size \(n\), then its valid indices are 0 to n-1. In most computer languages, arrays and lists start at index 0 and go up from there, meaning to count for items we have "0, 1, 2, 3".

      Warning!

      A common source of program crashes is going outside the bounds of an array! This happens if you try to access an invalid index, such as student[-1] or student[100] (for an array of size 100; valid indices are 0-99).

      Accessing array elements via index

      After we've declared an array, we can treat its elements like normal variables, storing data within it and accessing that data. Each one can be accessed via its index (position in the array) and the subscript operator: [].

      In math, you might be used to these subscripts:

      \[ a_n = a_{n-1} + 2 \]

      But with C++, subscripts look like this:

      a[n] = a[n-1] + 2

      So, declaring an array and accessing its values can look like this:

      Example: Declaring an array and storing values for each element, displaying the value of the element at index 0

      string courses[4];
      courses[0] = "CS 134";
      courses[1] = "CS 200";
      courses[2] = "CS 210";
      courses[3] = "ASL 120";
      
      cout << "First course: " << courses[0] << endl;
      

      Or, with modern C++ (from 2011 and later) you can initialize an array with an initializer list, {}

      Example: Using an initializer list to initialize an array's elements

      string courses[4] = {
        "CS 134",
        "CS 200",
        "CS 210",
        "ASL 120"
      };
      
      cout << "First course: " << courses[0] << endl;
      

      Design!

      It's common for array names to be plural - it is a structure that stores multiple items - multiple courses, multiple products, multiple grades, etc. So, to be clear, it is best to give your arrays plural names: courses, products, grades, instead of singular.

      Review 5. Given an array declared like this:

      string cats[4];
      

      The first element is at index __ and the last element is at index __.

      Review 6. Given this array:

      [?]	[?]	[?]	[?]	[?]
      Kat	Kabe	Luna	Pixel	Korra

      Assuming the first item is on the left and the last item is on the right, what is the element at index 3?

3. Arrays and memory
   

   

   When we declare any variable it is assigned a memory address as it is stored somewhere in memory. You can think of this as it being stored in RAM (though the operating system abstracts this a bit more). When a program starts and variables are declared, space is taken up "in RAM" and then freed when the program closes or when the variable is destroyed. This way, other programs running in the operating system can utilize that space.

   A memory address is a numeric value. Computers work on binary, but we often write memory addresses in hexadecimal to shorten the length of the addresses. An example memory address is: 0x7ffd1f7ba26c.

   Example: Here's a simple program that creates two different variables, assigns values, and outputs the values and their memory addresses:

   int main()
   {
       int num = 10;
       string name = "Hello!";
   
       cout << "The variable 'num' has a value of " << num
            << "\n at the address " << &num << endl << endl;
       cout << "The variable 'name' has a value of " << name
            << "\n at the address " << &name << endl;
   
       return 0;
   }
   

   When it is run, it will give output like this:

   The variable 'num' has a value of 10
   at the address 0x7fff28b210bc
   
   The variable 'name' has a value of "Hello!"
   at the address 0x7fff28b210c0
   

   Contiguous addresses

   When a variable is declared, it will automatically have space allocated in memory. For an array's elements, those elements are going to be side-by-side in memory (contiguous).

   Let's say we have an array of bool elements, which are 1 byte each. If we declare it like this:

   bool arr[4];
   

   the address of each element might be something like…

   Address of arr[0]: 0x7ffeeb9740d4
   Address of arr[1]: 0x7ffeeb9740d5
   Address of arr[2]: 0x7ffeeb9740d6
   Address of arr[3]: 0x7ffeeb9740d7
   

   The addresses would change each run, but they will always be 1 byte apart in memory, since each bool is 1 byte big.

   Let's also look at an array of integers. Each int is 4 bytes. We declare it like this:

   int arr[4];
   

   the address of each element might be something like…

   Address of arr[0]: 0x7ffded346a70
   Address of arr[1]: 0x7ffded346a74
   Address of arr[2]: 0x7ffded346a78
   Address of arr[3]: 0x7ffded346a7c
   

   Each element is still side-by-side in memory, but since each int takes 4 bytes, each address is offset by 4. (0… 4… 8… then c which is 12.)

   Review 7. The elements of an array will be stored…

   • ○ at random

   • ○ side-by-side

     … in memory.

4. Design patterns
   

   Since arrays require quite a bit of management to work with, you could implement some basic functions to do this management, instead of having to re-write the same code over and over.

   1. Storing array size and item count
      

      

      Let's say we have our student array and a maximum amount of 22 seats:

      const int TOTAL_SEATS = 22;
      string students[TOTAL_SEATS];
      

      One design consideration to think about here is that, if we iterate from i = 0 to TOTAL_SEATS, we're going to iterate over seats that have students AND seats that are empty. What if we were writing a program and JUST wanted to display a list of students enrolled in the course, and not waste paper space or screen space drawing blank links for empty seats?

      In this case we usually need to keep a variable to track how many items we're actually storing in the array. For example:

      int studentCount;
      

      so the TOTAL_SEATS would be the size of the array, but the studentCount might be less than or equal to that number. Every time we added a student we would add +1 to the studentCount. That way, we could use studentCount in our for loop to display just active students, none of the empty seats.

      

      … The TOTAL_SEATS remain the same, even as the studentCount grows from more students taking up space in available seats…

      

      Review 8. Let's say we have our array of students and the TOTAL_SEATS is 22, and the studentCount begins at 0. After three students register for the course, then

      TOTAL_SEATS value is: __ and studentCount value is: __

   2. Accessing indices with variables
      

      Since the array index is always an integer, we could use a variable to determine which item in an array to modify - such as asking the user which item they want to edit.

      Example: Asking the user to enter an index and displaying the element at that index

      cout << "Edit which item? (0-9): ";
      cin >> itemIndex;
      cout << "Enter price for item: ";
      cin >> prices[ itemIndex ];
      

   3. Asking the user to enter all elements
      

      Using for loops is the most common way to iterate over all the data in an array, setting data or accessing data. Have an array of size n? We want to iterate from i = 0 to \(n-1\), going up by 1 each time.

      We can iterate over all the items in an array and have the user enter information for each element by using a loop. Since the first index is 0, we sometimes just add +1 to the index for the user's benefit, since people generally aren't used to lists starting at 0.

      const int TOTAL_ITEMS = 10;
      float prices[TOTAL_ITEMS];
      
      for ( int i = 0; i < TOTAL_ITEMS; i++ )
      {
        cout << "Enter price for item " << (i+1) << ": ";
        cin >> prices[i];
      }
      

   4. Displaying all items in an array
      

      We can display all the elements of an array by using a loop as well, though we usually don't want to show all elements of the array - usually just the items we know we're storing data in. Recall that we usually will have an extra integer variable to count how many items have actually been stored in the array, which is different from the total array size.

      const int MAX_STUDENTS = 100;
      int studentCount = 0;
      string students[MAX_STUDENTS];
      
      // (...Let's say 20 students were added here...)
      
      // Iterate from index 0 to 19, since we have stored
      // 20 students so far.
      for ( int i = 0; i < studentCount; i++ )
      {
        cout << "Student " << (i+1)
          << " is " << students[i] << endl;
      }
      

      You can also use a range-based for loop in versions of C++ from 2011 or later:

      for ( auto & student : students )
      {
        cout << student << endl;
      }
      

   5. Clear array
      

      Sets all elements of this string array to an empty string and resets the elementCount to 0 afterwards.

      Example: Iterating over an array and setting each element's value to 0

      void Clear( string arr[], int & elementCount )
      {
        for ( int i = 0; i < elementCount; i++ )
        {
          arr[i] = "";
        }
        elementCount = 0;
      }
      

   6. Add new element to array
      

      Often in our programs we will only set up one item at a time (perhaps when selected from a menu). This means we need to get the data for the array and figure out where in the array it will go.

      void AddItem( string arr[], int & elementCount )
      {
        cout << "Enter new element: ";
        cin >> arr[ elementCount ];
        elementCount++;
      }
      

      For an array, elementCount starts at 0 when the array is empty. This also happens to be the index where we will insert our first element - at 0.

      Element
      Index	0	1	2	3

      Once we add our first element, our elementCount will be 1, and the next index to insert data at will also be 1.

      Element	Cats
      Index	0	1	2	3

      Then, elementCount will be 2, and the next index to insert at will be 2.

      Element	Cats	Dogs
      Index	0	1	2	3

      Because of this, the elementCount variable both tells us how many items have been stored in the array and what is the next index to store new information at.

      Review 9. If we had an array declared like this:

      string names[5];
      

      The for loop header to iterate over all the elements would look like…

      for( ________________ ; ________________ ; ________________ )

      Review 10. What does the following code snippet do?

      for ( int i = 0; i < ARRAY_SIZE; i++ )
      {
          employeeWage[i] += 5.12;
      }
      

      • ○ Iterates over all elements in the employeeWage array and adds 5.12 to each item.
      • ○ Iterates over all elements in the employeeWage array and displays each element's value to the screen.
      • ○ Iterates over all elements in the employeeWage array and overwrites each element with a value of 5.12.
   7. Parallel arrays
      

      Let's say we're writing a simple restaurant program where we need a list of dishes and their prices together. Later on, we will write our own data type using structs and classes to keep these items together. But for now, we would implement this relationship by keeping track of two separate arrays with the data we need.

      This is an option, design-wise, however usually it's better to store the two arrays within a structure or class instead of making parallel arrays.

      Example: Using 3 parallel arrays to store a dish's name, price, and if its vegetarian

      const int MAX_DISHES = 20;
      int dishCount = 0;
      
      // Information about a dish
      string  dishNames[MAX_DISHES];
      float   dishPrices[MAX_DISHES];
      bool    dishVegetarian[MAX_DISHES];
      
      // ... Let's say we created some dishes here...
      
      // Display the menu
      cout << "What would you like to order?" << endl;
      for ( int i = 0; i < dishCount; i++ )
      {
        cout << "Dish #" << i << ":" << endl;
        cout << "* Name:   " << dishNames[i] << endl;
        cout << "* Price: $" << dishPrices[i] << endl;
      
        if ( dishVegetarian[i] ) {
          cout << "* Is vegetarian" << endl;
        }
      
        cout << endl;
      }
      
      // Get the index of dish they want
      int whichDish;
      cout << "Selection: ";
      cin >> whichDish;
      

5. Multidimensional arrays
   

   We can declare an array with two dimensions. A 1 dimensional array we can think of like this:

   CS134

   CS200

   CS210

   CS211

   CS235

   Whereas a 2 dimensional array we can think of like a spreadsheet with multiple rows and columns:

   CS134	Spring 2022	PW	A
   CS200	Summer 2022	RS	A
   CS235	Fall 0222	RS	A

   Or even as a 2D display on a screen with an (x, y) position for pixels:

   

   Generally when talking about rows and columns, rows comes first and columns come second.

   Row is a horizontal grouping of information, a column is a vertical grouping of information. On a spreadsheet, a "cell" is a single item denoted by a row and a column.

   

   Often, the column relates to a specific field of data (such as a student's name, age, gpa, etc.) - Think of a struct and its member variables.

   Then, each row corresponds to one record. So if we had an array of students, each row would be student 0, 1, 2, 3, etc. and then each column would be name, age, gpa, etc.

   1. Example: Displaying all the elements of a 2D array
      

      To display the contents of a 2D array, it can be useful to have two for loops, one nested in the other. The outer for loop will only increment once the inner one finishes its cycle. I usually put the rows as the outer loop and the columns as the inner-loop.

      for ( int row = 0; row < ROWS; row++ )
      {
          cout << "Row: " << row << endl;
          for ( int col = 0; col < COLUMNS; col++ )
          {
              cout << "\t Col: " << col
                   << ": " << arr[row][col]
                   << endl;
          }
      }
      

   2. Example: Declaring a 2D and a 3D array
      

      string spreadsheet[32][32]; // rows and columns
      int vertices[4][4][4];    // x, y, z
      

      Let's say we wanted to turn a day planner into a program. Perhaps we originally stored the day plan like this:

      Day	Time	Task
      Monday	8:00	Work meeting with Bob
      Monday	13:00	Project review
      Tuesday	10:00	Customer meeting
      Tuesday	12:00	Crying in car
      Wednesday	14:00	Sprint Retrospective

      We can convert this into a 2D array of strings (the "task"), with one dimension being for "day of the week" and the other dimension being for "hour of the day"…

   3. Example: Declaring a 2D array of strings
      

      int DAYS_OF_WEEK = 7;
      int HOURS_IN_DAY = 24;
      string todo[ DAYS_OF_WEEK ][ HOURS_IN_DAY ];
      

      We could ask the user what day they want to set a task for, and if they type "Sunday" that could translate to 0, and "Saturday" could translate to 6 (or however you want to organize your week)…

      Sunday	Monday	Tuesday	Wednesday	Thursday	Friday	Saturday
      0	1	2	3	4	5	6

      We could ask them next for what hour the task is at, and that can map to the second index: "0" for midnight, "8" for 8 am, "13" for 1 pm, and so on to 23.

      With this information, we can get the user's todo task and store it at the appropriate indices:

   4. Example: Asking the user to enter a day and hour and using those as indices
      

      int day, hour;
      
      cout << "Enter the day:" << endl;
      cout << "0. Sunday    \n"
           << "1. Monday    \n"
           << "2. Tuesday   \n"
           << "3. Wednesday \n"
           << "4. Thursday  \n"
           << "5. Friday    \n"
           << "6. Saturday  \n";
      
      cout << "Day: ";
      cin >> day;
      
      cout << "Enter the hour (0 to 23): ";
      cin >> hour;
      
      cout << "Enter your task: ";
      cin >> todo[ day ][ hour ];
      

      With the user's week planned out, you could then display it back to the user by using a nested for loop: One loop for the day, one loop for the hour.

   5. Example: Nested for loop to display all elements of the 2D array
      

      cout << "YOUR SCHEDULE" << endl;
      
      for ( int day = 0; day < DAYS_OF_WEEK; day++ )
      {
        for ( int hour = 0; hour < HOURS_IN_DAY; hour++ )
        {
          cout << day << ", "
               << hour << ": "
               << todo[ day ][ hour ] << endl;
        }
      }
      

      Though you'd probably want to do some extra formatting; such as determining that if the day is 0, then write "Sunday" instead of the number "0".

      Review 11. Even with a 2-dimensional array each element is still the same data type. You declare a 2d array similarly to a 1d array, but with an extra size:

      const int ROWS = 10;
      const int COLUMNS = 3;
      string spreadsheet[ROWS][COLUMNS];
      

      Given 10 rows and 3 columns, how many elements would this be?

      Review 12. To display the contents of a 2D array, it can be useful to have two for loops, one nested in the other. The outer for loop will only increment once the inner one finishes its cycle.

      Given the following 2D array declaration:

      const int ROWS = 3;
      const int COLUMNS = 4;
      string pixelColors[ROWS][COLUMNS];
      

      How would you create for loops that will display the element data like this?

      Row: 0
         Col: 0: #00ffff
         Col: 1: #ff00ff
         Col: 2: #000000
         Col: 3: #00ff00
      Row: 1
         Col: 0: #000000
         Col: 1: #00ffff
         Col: 2: #ff0000
         Col: 3: #0000ff
      Row: 2
         Col: 0: #000000
         Col: 1: #ffff00
         Col: 2: #ff0000
         Col: 3: #00ff00
      

6. Common errors
   

   What happens if we have an array declared like this:

   float prices[5];
   

   But we try to access an index that it outside its range, like…

   cout << prices[-1];
   cout << prices[100];
   

   If this occurs, this is an out of bounds error, and will cause the program to crash! So now we have a very reliable way to crash our programs now. :)

   Review 13. Given the array declaration:

   int myArr[10];
   

   Are any of the following out of bounds?

   • myArr[0] is ○ OK / ○ Out-of-bounds
   • myArr[5] is ○ OK / ○ Out-of-bounds
   • myArr[10] is ○ OK / ○ Out-of-bounds
   • myArr[11] is ○ OK / ○ Out-of-bounds

5.5.3. 📚 Intro: STL Array and STL Vector