CS 200: Concepts of Programming using C++ (Spring 2024 version)

🅰️ Pre-test (PRETEST.202401.CS200)

👋 Introductions!

❓ Unit 00 Setup - GitLab Username

📊 Presentation - Set up (U00.PRES)

📖️ Reading - Welcome (U00.READ)

• Welcome!
  

  It feels weird to start a collection of notes (or a "textbook") without some sort of welcome, though at the same time I know that people are probably not going to read the introduction (Unless I put some cute art and interesting footnotes, maybe.)

  I think that I will welcome you to my notes by addressing anxiety.

  Belonging

  Unfortunately there is a lot of bias in STEM fields and over decades there has been a narrative that computer science is for a certain type of person - antisocial, nerdy, people who started coding when they were 10 years old.

  Because of this, a lot of people who don't fit this description can be hesitant to get into computers or programming because they don't see people like themselves in media portrayals. Or perhaps previous professors or peers have acted like you're not a real programmer if you didn't start programming as a child

  If you want to learn about coding, then you belong here.

  There are no prerequisites.

  I will say from my own experience, I know developers who fell in love with programming by accident as an adult after having to take a computer class for a different degree. I know developers who are into all sorts of sports, or into photography, or into fashion. There is no specific "type" of programmer. You can be any religion, any gender, any color, from any country, and be a programmer.

  

  Figure 1: Don't be like Gatekeeper Baby. You can begin coding at any age!

  Challenge

  Programming can be hard sometimes. There are many aspects of learning to write software (or websites, apps, games, etc.) and you will get better at it with practice and with time. But I completely understand the feeling of hitting your head against a wall wondering why won't this work?! and even wondering am I cut out for this?! - Yes, you are.

  

  I will tell you right now, I have cried over programming assignments, over work, over software. I have taken my laptop with me to a family holiday celebration because I couldn't figure out this program and I had to get it done!!

  All developers struggle. Software is a really unique field. It's very intangible, and there are lots of programming languages, and all sorts of tools, and various techniques. Nobody knows everything, and there's always more to learn.

  Just because something is hard doesn't mean that it is impossible.

  It's completely natural to hit roadblocks. To have to step away from your program and come back to it later with a clear head. It's natural to be confused. It's natural to not know.

  But some skills you will learn to make this process smoother are how to plan out your programs, test and verify your programs, how to phrase what you don't know as a question, how to ask for help. These are all skills that you will build up over time. Even if it feels like you're not making progress, I promise that you are, and hopefully at the end of our class you can look back to the start of it and realize how much you've learned and grown.

  Learning

  First and foremost, I am here to help you learn.

  My teaching style is influenced on all my experiences throughout my learning career, my software engineer career, and my teaching career.

  I have personally met teachers who have tried to scare me away from computers, I've had teachers who really encouraged me, I've had teachers who barely cared, I've had teachers who made class really fun and engaging.

  I've worked professionally in software and web development, and independently making apps and video games. I know what it's like to apply for jobs and work with teams of people and experience a software's development throughout its lifecycle.

  And as a teacher I'm always trying to improve my classes - making the learning resources easily available and accessible, making assignments help build up your knowledge of the topics, trying to give feedback to help you design and write good programs.

  As a teacher, I am not here to trick you with silly questions or decide whether you're a real programmer or not; I am here to help guide you to learn about programming, learn about design, learn about testing, and learn how to teach yourself.

  

  Roadmap

  

  When you're just starting out, it can be hard to know what all you're going to be learning about. I have certainly read course descriptions and just thought to myself "I have no idea what any of that meant, but it's required for my degree, so I guess I'm taking it!"

  Here's kind of my mental map of how the courses I teach work:

  CS 200: Concepts of Programming with C++

  You're learning the language. Think of it like actually learning a human language; I'm teaching you words and the grammar, and at first you're just parroting what I say, but with practice you'll be able to build your own sentences.

  CS 235 Object-Oriented Programming with C++

  You're learning more about software development practices, design, testing, as well as more advanced object oriented concepts.

  CS 250 Basic Data Structures with C++

  You're learning about data, how to store data, how to assess how efficient algorithms are. Data data data.

  In addition to learning about the language itself, I also try to sprinkle in other things I've learned from experience that I think you should know as a software developer (or someone who codes for whatever reason), like

  • How do you validate that what you wrote actually works? (Spoilers: How to write tests, both manual and automated.)
  • What tools can you use to make your programming life easier? (And are used in the professional world?)
  • How do you design a solution given just some requirements?
  • How do you network in the tech field?
  • How do you find jobs?
  • What are some issues facing tech fields today?

  Something to keep in mind is that, if you're studying Computer Science as a degree (e.g., my Bachelor's degree is in Computer Science), technically that field is about "how do computers work?", not about "how do I write software good?" but I still find these topics important to go over.

  

  That's all I can really think of to write here. If you have any questions, let me know. Maybe I'll add on here.

  \vspace{0.2cm}

• What is this weird webpage/"book"?
  

  In the past I've had all my course content available on the web on separate webpages. However, maintaining the HTML, CSS, and JS for this over time is cumbersome. Throughout 2023 I've been adapting my course content to emacs orgmode documents, which allows me to export the course content to HTML and PDF files. I have a few goals with this:

  1. All course information is in one singular place
  2. At the end of the semester, you can download the entire course's "stuff" in a single PDF file for easy referencing later on
  3. Hopefully throughout this semester I'll get everything "moved over" to orgmode, and in Summer/Fall 2024 I can have a physical textbook printed for the courses, which students can use and take notes in so as to have most of their course stuff in one place as well
  4. It's important to me to make sure that you have access to the course content even once you're not my student anymore - this resource is available publicly online, whether you're in the course or not. You can always reference it later.

  I know a lot of text can be intimidating at first, but hopefully it will be less intimidating as the semester goes and we learn our way around this page.

  \vspace{0.2cm}

• What kind of tools are needed to make programs?
  

  

  To write software, we need to write instructions - the program source code is the list of instructions. This means we need some kind of text editor program.

  To turn the program instructions into stuff humans can read into stuff computers can read (that is, binary, or an executable file), we need a compiler program.

  These are the two things that are needed at minimum, but there are plenty more tools to help us be more effective at our jobs. For instance, if you use the default "Notepad" on Windows it's going to be a bunch of black text on a white background. If you use a text editor meant for code, however, you'll get syntax highlighting - which color-codes different commands, helping us read the code more clearly.

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

  (If this doesn't show up in color, just pretend it does and that it makes it easier to read.)

  Since we'll be writing a lot of different programs and referring back to these programs throughout the semester you will also want to keep things organized and backed up. There is special software that software developers use to keep track of their code changes over time, called source control or version control. We will be using the Git version control system in this course, though we are going to stick to the web interface view for this introductory course.

  ---

• Review questions:
  
  1. What kind of program is needed to convert human-readable code into computer binary executables?
  2. Computer CPUs only understand what "language"?
  3. What kind of program is used by professionals to store their code and keep track of changes?

  We will explore more about how computers work later on, but for now, let's get our tools set up!

  After the reading, complete the assignment: 🔎 Unit 00 Concept Intro - Welcome/setup (U00.CIN)

  \newpage

🧑‍🔬 Lab - Set up (U00.LAB)

• Creating a GitLab account
  

  1. Go to the sign up page: Start by going to https://gitlab.com/users/sign_up and fill out the form to create your account.

  

  Fill out your first and last name, a username, email address, and password. Note that if you want to maintain your privacy you might use an alternative email/name, but make sure to let the instructor know who you are!

  2. Navigate to your profile page: After registering, going to https://gitlab.com/ should take you to a "Projects" page. You will be able to view your repositories here later on. On the right-hand sidebar, click on your profile image (it might be some default picture), then click on the top section to go to your profile.

  

  3. Bookmark your profile page: Once you're on your profile page, the URL will look something like this: https://gitlab.com/YOURUSERNAME Take note of this URL and bookmark this page. You may also need to give this link to the instructor for further setup.

  

• Accessing your GitLab repository
  

  Make sure the instructor knows your GitLab profile name. For example: https://gitlab.com/YOURUSERNAME . They will set up your class repository, where you will be able to upload your code for the semester.

  Why are we using a repository? Using source control software such as git is an important tool of software developers in the real world. Now is a great chance for us to get practice working with source control before entering the real world. Plus, it has these benefits:

  • Back up your source code to a server so you can access it anywhere and don't lose your code! (And you can refer back to it once the semester ends, for future class reference! :)
  • Your instructor can view your repository and code from their own machine, which helps with debugging issues!

  Once you're given access to your repository you'll be able to find it at a URL like https://gitlab.com/users/YOURUSERNAME/contributed , though you might want to bookmark the repository link as well!

  A repositoroy link looks like this: https://gitlab.com/rsingh13-student-repos/GROUP_NAME/REPOSITORY_NAME - the instructor will create the repository for you and have a basic structure set up, and then you can upload your work for each assignment.

  

  Your starting repository will probably look different from this one - this is just a past example! :)

• Downloading the starter code templates
  

  Once you have access to your repository, you will see that it already has folders and files created within it. These are the starter code items that we will be using throughout the semester.

  Click on the blue Code button, and at the bottom of the dropdown select the zip button.

  

  After the zip file is downloaded, make sure to extract it to your hard drive.

  

  Task: Take a screenshot of the cs200 folder extracted on your hard drive.

  This is to show me that you were able to download and unzip the folder correctly.

• Setting up the compiler
  

  IF YOU'RE ON A MAC COMPUTER, use this video for a guide on how to install g++ and build a basic C++ program.

  https://www.youtube.com/watch?v=gnq8VUGRV68

  If you're using a school lab computer they will already have the software we need set up. Use these instructions for setting up the programs on your own computer.

  • Installing a C++ compiler on Windows:
    

    On Windows we're going to use the MinGW compiler to build our C++ programs into executable (.exe) files.

    \vspace{0.2cm}

    1. Go to https://sourceforge.net/projects/mingw/ and click Download.

    

    2. Save the install file to your computer and run it.

    3. On the first page, click the "Install" button.

    4. Choose a path to install the compiler. You can leave the other items as the defaults.

    

    5. It will download some needed items. Click "Continue" once it's done.

    

    6. On the main installer page, click the checkbox next to the "mingw32-gcc-g++" option.

    

    

    7. Then, click on the "Installation" dropdown menu and select "Apply Changes".

    

    8. It will ask "Okay to proceed?". Click "Apply" to continue. Once all the changes are done, click "Close". You can then close the MinGW Installation Manager.

    9. Next, go to the path where MinGW was installed (by default, it's C:\MinGW). Go into the "bin" folder, and then select the address bar to turn it into text. Copy this path. This is the directory where the MinGW compiler program resides.

    

    10. Next, click on the Windows start bar and type in "Environment" and look for the option "Edit the system environment variables".

    

    11. In the System Properties screen, click on the "Environment Variables…" button.

    

    12. Highlight the Path field and then click the "Edit…" button.

    

    13. Paste your MinGW bin path into this editor then click "OK". You can then close out of the rest of the windows.

    

    Next we will build and run an example program. Skip the next setups for Linux and Mac to find the next section, "Build and run a test program".

    \vspace{1cm}

  • Installing a C++ compiler on Linux:
    

    From your package manager install the g++ package.

    

    Next we will build and run an example program. Skip the next setup for Mac to find the next section, "Build and run a test program".

    \vspace{1cm}

  • Installing a C++ compiler on Mac:
    

    TODO: DOCUMENT MAC COMPILER SETUP PROCESS

    Task: Take a screenshot of the MinGW bin directory in your Windows Explorer (Windows users only).

    This is to show me that you were able to install the compiler correctly.

    Task: Take a screenshot of your updated Environment Variables (Windows users only).

    This is to show me that you were able to configure the runnable program correctly.

• Build and run a test program
  

  Within the project folder, in the u00_Welcome you'll find the file test-program.cpp - we are going to build and run it to make sure that the compiler setup was a success.

  In Windows, hold the SHIFT key and right-click in the empty space of the folder. Select "Open PowerShell window here".

  

  To use the MinGW compiler to build our .cpp file, use the command: g++ test-program.cpp. By default, this will generate an executable file named a.exe.

  

  Task: Take a screenshot of you building the program in the Shell using g++.

  This is to show me that you were able to build the program correctly.

  If the build is successful, it won't display any additional information but it will return you to the prompt. To run the program, use: ./a.exe and hit ENTER. It will show a little greeting:

  

  Task: Take a screenshot of you running the program using the ./a.exe command (or a.out for Linux/Mac).

  This is to show me that you were able to run the program correctly.

• Setting up a code editor
  

  If you're using a school lab computer they will already have the software we need set up. Use these instructions for setting up the programs on your own computer.

  You can use any code editor that you'd like to use. In my example screenshots, I will be using Geany (https://www.geany.org/) but you may have other preferences. VSCode (https://code.visualstudio.com/) is another popular option though it is a Microsoft product.

  \vspace{0.5cm}

  Once you've installed a text editor, open the test-program.cpp file in the text editor. You will see some basic C++ code. Change the world text to say something else, like your name.

  After any changes are made to source code you must recompile the program for the executable file to show the updates. So, if you run g++ test-program.cpp again, next time you run the program with ./a.exe you'll get updated text:

  

• Uploading your work to your repository
  

  Task: Edit the test-program.cpp file and paste in your changes to this file.

  Finally, we are going to upload our updates to the GitLab repository. First, navigate to the file from the GitLab webpage view. Click on the test-program.cpp file here.

  

  Next, you can click on the "Edit" dropdown menu. Select "Edit single file".

  

  Copy your updated code from your text editor and paste it into this web editor so it will have your latest changes. Scroll down afterwards and click the "Commit" button.

  

  The file will be updated.

  Task: Upload your screenshots into the u00_Welcome folder in your repository.

  To upload a file to a folder in your repository, click on the "+" button next to the current folder path, and then select "Upload file".

  

  Select the file to upload, add a comment about the file, and click Upload file.

  

  Your file will now be in the repository.

  

  Task: Copy the URL of the u00_Welcome folder in your repository.

  You will turn this in on Canvas.

• Turning in your work on Canvas
  

  To turn in your work on Canvas, first go to your GitLab repository and copy the URL that belongs to the file(s) you edited.

  

  In Canvas, locate the assignment with the matching name. Click on the "Start Assignment" button.

  

  Next, make sure you're on the Website URL tab. Paste in the file's URL that you just copied, then click "Submit Assignment".

  

  I will then grade the assignment. In this case, it's just a "Complete/Incomplete" grade, but with most assignments I'll mark the amount of points you've earned based on some criteria. You are welcome to submit fixed code afterwards as well.

📊 Presentation - Exploring software (U01.PRES)

📖️ Reading - Exploring software (U01.READ)

• A brief history of software
  

  A computer needs to be told how to do everything. If you were writing a program totally from scratch, you would have to tell it how to load a bitmap file, how to draw a rectangle, how to detect mouse clicks, how to animate a transition, and everything else.

  However, software has been evolving for decades now, and a lot of these features are already implemented in libraries. Libraries are sets of pre-written code meant for other programs to import and use.

  With some of the first computers, the only commands you could program in directly mapped to the hardware on the machine (machine code / assembly). Later, developers such as Grace Hopper worked on ways to write code that lets you fit multiple machine-code-pieces into one command that was more human-readable, leading to early languages like COBOL.

  Many of these "higher-level" languages (higher-level meaning further from the hardware; more abstracted) eventually will get turned into machine code through a process called compiling.

  // Example C++ program
  #include <iostream>
  using namespace std;
  
  int main()
  {
      cout << "Hello, world!" << endl;
      return 0;
  }
  

  And here is the corresponding assembly code:

  // Corresponding assembly code
  ;5  :	{
  0x5555555551a9	endbr64
  0x5555555551ad	push   rbp
  0x5555555551ae	mov    rbp,rsp
  ;6  :	    cout << "Hello, world!" << endl;
  0x5555555551b1	lea    rsi,[rip+0xe4c]        # 0x555555556004
  0x5555555551b8	lea    rdi,[rip+0x2e81]        # 0x555555558040 <std::cout@@GLIBCXX_3.4>
  0x5555555551bf	call   0x555555555090 <std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)@plt>
  0x5555555551c4	mov    rdx,rax
  0x5555555551c7	mov    rax,QWORD PTR [rip+0x2e02]        # 0x555555557fd0
  0x5555555551ce	mov    rsi,rax
  0x5555555551d1	mov    rdi,rdx
  0x5555555551d4	call   0x5555555550a0 <std::ostream::operator<<(std::ostream& (*)(std::ostream&))@plt>
  ;8  :	    return 0;
  0x5555555551d9	mov    eax,0x0
  ;9  :	}
  0x5555555551de	pop    rbp
  0x5555555551df	ret
  

  Compiled languages aren't the only variety - Java runs in a Java Virtual Machine, and Python is a scripting language that runs via a Python executable. But we're focusing on C++ here.

  The point is, modern software is built on top of many layers: high-level languages that compile down to machine code, pre-written libraries of code that handle common features for the programmers so they don't have to reinvent the wheel.

• What is a program?
  

  Since a computer needs to be told how to do everything, a computer program is a list of very specific instructions on how to execute some task (or tasks, for larger programs).

  

  Figure 2: Inputs and Outputs

  • Inputs:
    

    Some programs don't take any input and just run a set of pre-defined instructions. Most programs do take some form of input, however, whether that's when the program first starts up or during its runtime.

    Inputs could include things like passing in a filename to a program (e.g., please open this file) or other pieces of data, or getting keyboard input, gamepad input, mouse input, touch screen input, or receiving signals via the network or internet.

  • Outputs:
    

    Programs also often will return some form of output, but this is also optional. If a program doesn't return output, maybe the user just wants to tell the program to do a job, but doesn't need confirmation that the job was done (these are usually called background processes).

    Outputs could be something like displaying a message box, changing text on the screen, playing a sound, or writing out a text file.

    

    Figure 3: Variables

  • Variables:
    

    Our program may also use variables to store data during its execution. Variables are locations in memory (RAM) where we can store numbers, text, or more complex objects like an image. We give variables a name to reference it by, such as userName or cartTotal, and we can do math operations on it, as well as write it to the screen or read new values into it from the user.

  • Branching and looping:
    

    

    Figure 4: Branching

    We can also change the instructions our program runs based on some condition we set. For example, if bankBalance < 0 then maybe we display an error message. Otherwise, we can withdraw some amount of money from the bankBalance.

    

    Figure 5: Looping

    We may also want to take advantage of looping to do a set of instructions repeatedly, possibly with some variables changing each time through the loop. An example for this could be to loop over all of a student's assignmentGrades, adding up all the points so we can find an average.

  • Example programs
    

    Area calculator

    This program asks the user to enter a width and a height and then calculate the area of the rectangle with the given information.

    cout << "Width: ";      // Display message
    cin >> width;           // Get user input
    
    cout << "Height: ";     // Display message
    cin >> height;          // Get user input
    
    area = width * height;  // Do math
    
    cout << "Area: " << area << endl;
    

    Recipe program

    This program asks the user how many batches of a recipe they'd like to make. Then, it adjusts the ingredient amounts for each ingredient and displays the updated ingredient list to the screen.

    cout << "How many batches? "    // Display message
    cin >> batches;                 // Get user input
    
    flour       = 2.75 * batches;   // Calculate amounts
    bakingSoda  = 1 * batches;
    butter      = 1 * batches;
    whiteSugar  = 1.5 * batches;
    eggs        = 1 * batches;
    vanilla     = 1 * batches;
    
    cout << flour << " cups flour" << endl;
    cout << bakingSoda << " tsp baking soda" << endl;
    cout << butter << " cups butter" << endl;
    cout << whiteSugar << " cups white sugar" << endl;
    cout << eggs << " eggs" << endl;
    cout << vanilla << " tsp vanilla" << endl;
    

    ATM - Withdrawing money

    This program asks the user how much they'd like to withdraw from their account. If the withdraw amount is more than their account balance, then an error message is displayed. Otherwise, the amount is withdrawn from their bank account.

    cout << "Withdraw: ";       // Display message
    cin >> withdrawAmount;      // Get user input
    
    if ( withdrawAmount > bankBalance )
        cout << "Error! Not enough money." << endl;
    else
        bankBalance = bankBalance - withdrawAmount;
    

• C++ Programs
  

  Each programming language is a little different in how it looks, but whether you're using C++, Java, C#, Python, or many other languages, you'll still encounter branching with if statements, looping, functions, and classes (though older languages may not have classes at all, like C!).

  • main(): The starting point
    

    With C++, Java, and C#, programs must begin in a function called `main()`. The compiler (that turns the program into machine code) is always expecting `main()` to be there and to begin running the program at the top of it.

  • Basic C++ syntax
    

    In C++, Java, C#, and other C-like languages, there are some basic rules of syntax you should know about:

    • Lines of code:
      

      A code statement ends with a semi-colon. Statements are single commands like cout (console-out) to display text to the output, cin (console-in) to read input from the keyboard, declaring variables, assigning variables, or doing math operations.

    • Variable names:
      

      There are some rules for naming variables in C++. Generally, you can use any upper or lower case letters, numbers, and underscores in variable names - no spaces allowed. Beyond that, variables cannot begin with a number, and you cannot use a keyword (such as if) as a variable name.

    • Code blocks:
      

      There are certain types of instructions that contain additional code. If statements, for example, contain a set of instructions to execute only if its condition evaluates to `true`. Any time an instruction contains other instructions, we use opening and closing curly braces {} to contain this internal code. Additionally, with these instructions, they do not end with semicolons.

    • Comments:
      

      It is often useful to add comments to programs to specify what is going on in the code. There are two ways to add comments in C++. Generally, you can use any upper or lower case letters, numbers, and underscores in variable names - no spaces allowed. Beyond that, variables cannot begin with a number, and you cannot use a keyword (such as if) as a variable name.

    • Whitespace and code cleanliness:
      

      Generally, C++ doesn't care if multiple commands are on one line or several lines. The compiler is going to compile it all either way. You should, however, care about the code's readability to humans. Add enough new lines to separate sections of a program, use consistent indentation, and give variables descriptive names.

      When writing code inside of a code block, you should always tab forward internal code by one tab:

      if ( order == "dessert" )
        {
          // One tab forward
          cout << "Order: dessert" << endl;
      
          if ( have_cake )
            {
              // One more tab forward
              cout << "You get cake!";
            }
          else
            {
              // One more tab forward
              cout << "Sorry, we're out of dessert!";
            }
        }
      

• Diagnosing, testing, and debugging
  

  

  Figure 6: Debugging

  Software is an amorphous, intangible thing of arbitrary complexity. It's bad enough when you're working alone, but once you get other people involved at varying skill levels (and varying levels of writing clean code), the amount of potential issues can quickly skyrocket.

  There are techniques to writing software that can help you validate your own logic and check for errors before they occur, as well as tools to help you diagnose and debug issues, as well as error messages to also help give hints to what's going wrong. All of these things are important to becoming a good software developer.

  • Synax, Runtime, and Logic errors
    
    • Syntax errors:
      

      The best type of error you can get is a syntax error, even though it may feel bad to get them. Syntax errors are when you have a typo or have otherwise miswritten a statement in the code, and the compiler doesn't know what to do with it. It will then display a build error telling you what it needs. Diagnosing syntax error messages can be confusing at first: often the compiler doesn't know exactly what's wrong, just what it's expecting. But, the good thing about syntax errors is that your program won't run if it can't build - that means you must fix these errors before continuing. It also means that these errors can't just be hidden in the code, like other error types.

    • Logic errors:
      

      Another type of error that's much harder to track down are logic errors. Logic errors can be errors in formulas, bad if statement conditions, or other things that don't do what the programmer was intending to do (again, either because of a typo, or not quite understanding the program flow, or for other reasons). Logic errors don't show up in the error list, but can cause your program to crash down the line - or worse, never crash but create bad output. Because it's not crashing, you may assume everything is working fine, but incorrect output can cause problems.

    • Runtime errors:
      

      When a logic error causes the program to crash while it's running, it is called a runtime error.

  • Debugging
    

    At some point, you will need to debug a program that builds and runs, but something is just wrong. Perhaps it crashes, or perhaps it just doesn't do what you expect it to. We will learn about how to use debugging tools in IDEs like Visual Studio and Code::Blocks later on. Some of the tools included in a debugger are:

    • Breakpoints: You can set these in your code and when the program reaches that part it will pause execution. Then, you can investigate the values of different variables, and also keep stepping forward line-by-line to observe changes and program flow.
    • Watch windows: You type in variable names in these windows and it will show you the variable values at different points in the program (using breakpoints).
    • Call stack: This will show which functions have been called up until where you're paused in the program. This can be handy to see how the program flows between different functions.
    • Output here, there, everywhere:
      

      A common, though somewhat unsophisticated debugging technique, is to add output statements at various points in your program to essentially "trace" the program flow - what is getting executed? What is displayed before the program crashes? This technique takes more cleaning up after you're done, and is only so helpful, but it can be a good way to see how your program is running.

  • Testing
    

    Programs need to be tested. Starting off, you will probably be manually running the program, entering inputs, and checking outputs. However, this gets tedious after a while and you'll probably start entering gibberish as inputs and assuming everything works if it outputs something. Manual testing is good to do, but it is easy to become sloppy. You can also write code to automatically test certain things for you. This will become more relevant to us once we're working with functions in C++.

    The main idea behind testing is that programs or functions will be taking some sort of inputs, and given those inputs you have some expected outputs or results. If the actual outputs don't match the expected outputs, then there is something wrong.

    We will cover testing techniques more later on.

  • Coding techniques for newbies
    

    When you're first starting with C++, it can feel like your code just never works. It can be good to adopt a few of these practices while you're still new, to minimize errors and frustration:

    • Compile often: Get into the habit of using keyboard shortcuts to build your code after every few lines - especially when you're first starting out. If you write two lines of code and get a syntax error, it's much easier to diagnose than if you write a whole program and then build.
    • Search for syntax error messages: Most of these messages have been posted about before on boards like Stack Overflow. Reading through these can help give you insight into what the error means, and common ways to fix them.
    • Comment things out: If you have a lot of code but can't get it compiling and aren't sure what to do, you can comment out large chunks of the program until it builds again. Then, bit by bit, uncomment out different regions until you find what's causing the build error.

    These practices can help you become a more efficient and effective programmer, especially when you're first starting out. Debugging and testing are essential skills for any programmer, and learning them early can save you a lot of time and frustration in the long run.

    ---

    Review questions:

    1. Programs take in __ and return __.
    2. Variables are used to…
    3. Branching is used to…
    4. Loops are used to…

🔎 Concept Intro - Exploring software (U01.CIN)

🧠 Tech Literacy - Exploring software (U01.TEC)

• Early personal computers
  

  Before the 1980s computers were mostly owned and operated by the government, universities, and large corporations. During the 1980s, companies began selling computers, such as the Apple ][, Vic-20, Acorn, ZX Spectrum, and more. These computers were small, usually hooked into a home television set, and were interacted with through a keyboard - mice weren't standard early on. Additionally, often these computers didn't have a hard drive for long-term data storage - and just a very rudimentary operating system. Programs were on floppy disk, casette tape, or even cartridge, and data also had to be stored externally.

  Early \(5 \frac{1}{4}\) floppy disks had a capcity of only 360 KB to 720 KB, with smaller \(3 \frac{1}{2}\) inch floppy diskettes storing aronud 1.44 MB. _{(Numbers pulled from https://en.wikipedia.org/wiki/Floppy_disk)}. How big is this?

  Well, with 1 B (one bit), you can store two possible values: 0 or 1. A byte is eight bits, which can store 00000000 to 11111111, so numeric values between 0 and 255. If you were storing a series of text, one of 26 letters, you could use several bytes in a row to represent a sentence.

  • HELLO becomes 72 69 76 76 79 using the ASCII standard (number codes to represent letters and other things)
  • Converting the ASCII values to binary gives us 01001000 00100000 01000101 00100000 01001100 00100000 01001100 00100000 01001111

  We don't usually measure file size in Bytes anymore - usually we use Kilobytes KB (1 KB = 1024 B), Megabytes MB (1 MB = 1024 KB), Gigabytes (1 GB = 1024 MB), and Terabytes (1 TB = 1024 GB).

  Here's a comparison of common storage medium capacities:

  Floppy disk	Diskette	CD	DVD	Blu-Ray
  360 KB	1.44 MB	700 MB	4.7 GB	50 GB

  Beyond the lack of storage space, graphics modes were low resolution and only offered a few colors, if any. Often these computers also only had a speaker capabale of playing certain tones at certain frequencies - not recorded wave files. And since it was the early days of computing at home there wasn't really a standard to follow as far as interface design goes.

  The programs we'll be writing for this course will be similar to these early day programs - specifically, text-based programs with few (if any) colors.

  ---

• Computers before the Mouse
  

  

  Figure 7: A screenshot of a Vic-20 screen. Screenshot taken from the VICE VIC20 emulator. 3583 bytes free.

  Average people began being able to afford personal desktop computers during the 1980s. These computers usually had hookups for average television sets. The computers weren't very powerful, so the low resolution of a TV generally worked fine. With a computer like the Commodore Vic-20, it was able to display 22 columns of text (wide) and 23 rows of text (tall). Some computers had slightly higher resolutions, but these were still quite far from high resolution screens we know today.

  

  These computers did not have hard-drives to store data in the long-term. Instead, users often had to buy a floppy disk drive (or two!) or a casette tape reader. They could also sometimes read in programs from cartridges, similar to old video game systems. Input for these old computers were mostly the keyboard, and perhaps a joystick for playing games. With all of these constraints, software had to be small and low resolution.

  ---

• Early GUIs and the Mouse
  

  

  Figure 8: Original Apple Macintosh desktop sample, unattributed ()

  

  Figure 9: Screenshot of Microsoft Windows 1.0 operating environment showing MS-DOS Executive and other applications, screenshot taken by Remember the dot. ()

  Early Graphical User Interfaces (or GUIs) began popping up in the late 80s and early 90s, most notably with the Apple Macintosh and Microsoft Windows. The mouse was becoming part of a standard computer setup, and these operating systems provided a cursor (the little arrow pointer) to show where you're pointing to on the screen. This allowed everyday users to be able to work with their computer's software and configuration without having to memorize text commands or referring back to a manual.

  At this point hard drives were also more common, though still very tiny compared to today's systems. In the screenshot of Windows 1.0 above, it lists "Disk Space Free" as "30024K", which is basically about 30 MB.

  We still had constraints around low resolution, low memory, and low long-term storage, and programs were small and still pretty simple.

  ---

• Smart Phones and Touch-based input
  

  

  Desktop PCs were the main way to use computers throughout the 90s and 2000s, but in the late 2000s Smart Phones launched and a new design language was being created - touch screen-only devices. (RIP my Samsung Messager with a physical keyboard.) While touchscreens had existed before, often they were interacted with via a stylus.

  Designing around pressing the screen with a finger meant having to reimagine how we do our core operations, from mouse to finger. How do we scroll a page? (No mouse wheel…) How do we select an option? (With a mouse we'd single or double click, but double tap didn't catch on…)

  The widespread use of smartphones even affected how we designed webpages. No more pages full of text content that you navigate with the precision of a mouse, now pages evolved to fluidly fit whatever screen you were on, text links became buttons with clearly clickable regions, and expandable "burger" menus became more commonplace.

  

  Figure 10: Burger button

  Throughout the past two decades, memory and storage space continued to increase in capacity while getting cheaper, many tasks and much of our storage has been offloaded onto "cloud" servers elseware, and so many programs utilize the internet in order to perform its core functionality. For better or worse.

  ---

• Discussion board
  

  Tech Literacy Assignment:

  1. Look at some files on your computer or phone. Write down the sizes of some file types. What kind of file type were you looking at, and how big was it? Some example file formats are:
     • A text document written in a program like Word or LibreOffice Write (.docx, .odt files).
     • A .jpg of a photograph.
     • A video file.
  2. Play at least two of the following games for at least a few minutes:
     • Games:
       • Zork: https://www.pcjs.org/software/pcx86/game/infocom/zork1/
       • The Oregon Trail: https://www.pcjs.org/software/pcx86/game/other/1990/oregon_trail/
       • Lode Runner: https://www.scullinsteel.com/apple2/#lode_runner (IJKL to move, U and O to dig holes)
       • Rogue: https://www.pcjs.org/software/pcx86/game/other/1985/rogue/
  3. Answer the following questions:
     • Give an example of a phone app that you use.
     • Give an example of desktop software that you use.
     • Note which of the two games above you tried out.
     • Judge the user experience of each: Are they easy to navigate? Are the programs fast and responsive? Are there any noticable delays while using each program?
     • Choose one of the programs (phone app/desktop software/old games) and give a couple of examples of how you might improve the user interface, or overall user experience.

  Turn in: https://canvas.jccc.edu/courses/68294/modules/items/3771248

  \newpage

🏋️ Nonogram - Nonogram A (U01.EXE.N)

🧑‍🏫 Status Update - Welcome, Setup, Exploring Software (U01.SUP)

📊 Presentation - Command line programs (U02.PRES)

🧠 Tech Literacy - Command Line programs (U02.TEC)

• A brief history of interfacing with computers
  

  Early computers were a shared resource, with one mainframe computer shared by many people at a university, business, or elseware. People often wrote programs on paper punchcards using dedicated hardware separate from the computer itself. (See: 1964 IBM 029 Keypunch Card Punching Demonstration (CuriousMarc))

  

  Figure 11: By Pete Birkinshaw from Manchester, UK - Used Punchcard, CC BY 2.0,

  Similarly, early computers didn't necessarily utilize video screens or monitors for output. Since the computer was shared, you might drop off your batch of cards for your program and come back later for the result output. If you think about it, a paper-based printout was probably the most cost-effective way for this. (See: YouTube: The IBM 1401 Mainframe Computer Wishes you a Merry Christmas (CuriousMarc) - Feeding a mainframe punchcards and getting printed output)

  Even when video monitors were available for these mainframe computers, the computers were still a shared resource being used by multiple people sharing computer time. In cases like these, users would work at a terminal. These look like what we think of as computers, with a video display and a keyboard, but they don't do any processing on their own. These terminals were connected to the mainframe computer, allowing users in other locations to interact with it via a simple text interface.

  

  Figure 12: By IBM - https://digitaltmuseum.no/011015240147/22-0-ibm-modell-360-370, CC BY-SA 4.0, https://commons.wikimedia.org/w/index.php?curid=113477774

  Even as Personal Computers began taking root in households in the 1980s, only rudimentary graphics were available (if any), such as drawing large blocks with some basic colors, or drawing pixels at specific positions on a low resolution screen. For daily use, typed commands were still largely how people interacted with the operating system of their computer, and for many of their programs as well.

  

  Figure 13: A photo of a Vic-20 BASIC program displayed on a CRT television.

  If a program did offer some kind of graphical user interface, at the time there were no standards and programs by different developers would often have wildly different interfaces, keyboard shortcuts, and styles.

• Who uses command line programs these days?
  

  In a way, there are still challenges around different types of interfaces. We have computers running different operating systems like Windows, Mac OS, Linux, and Unix, we have smartphones running their own operating systems as well. Beyond that, people might install different types of software or configure their personal computers differently. Under the surface, however, there is still some form of command line, though the commands may differ between a Windows PowerShell and a Linux/UNIX Bash system. So, what do these non-GUIs offer in utility?

  Consistency

  Sometimes I try to help out a person on a Mac computer, though I have almost no experience with that operating system. Often, I find it more comfortable to navigate through the Mac Terminal to utilize the UNIX-like commands that are in common with Linux - such as ls to list files and folders in a directory. Rather than have to learn a GUI for a system I'll never use on my own, I can interact with it with a "common tongue" - the command line. :)

  Scriptability

  Think of the effort it takes to automate doing anything with a GUI - you'll need some kind of program or library that allows moving the mouse to some (x,y) position, hit mouse clicks, type keys, etc. And even then, windows in a GUI might move around. It's much easier to write a program script to automate running commands from a command line instead - it's just text commands!

  Speed

  Command lines generally can be more responsive than a GUI. I find that even on computers that aren't too old, Windows slogs along. Command lines don't necessarily use your computer's graphics card to make the windows semi-transparent and animate when they perform some operation. And in some cases it can be faster to type something like mkdir cs200 cs235 cs250 to create three folders than to go through the steps to move mouse to "File", move mouse to "New Folder", click, type "cs200", repeat twice more.

  Portability

  Being able to navigate a command line also makes it much easier to access remote computers. While you can run a computer remotely and work with the graphical operating system, it's still usually pretty sluggish. Instead, you could SSH into a computer and work with it from the command line and quickly perform some operations that you need, which could be remotely launching a build, restarting a server, or even writing some notes.

  Most average computer users aren't using the command line in their personal lives, but it is still a hugely useful tool for people who work in IT and software. With IT, imagine you have to configure 20 computers per classroom, for all the classrooms in a building - would it be easier to manually go configure those computers from their GUIs, or to write a script and run that script on each computer?

• Why Computer Science courses don't (usually) teach GUI creation
  

  GUI libraries change over time

  Java and C# have both gone through various different systems for creating GUIs, such as WPF for old Windows programs, Swing for Java-based programs. But eventually they go out of date and stop being used.

  C++ isn't "owned" by a company like Microsoft or Oracle

  so there's no company to package some kind of UI library as the de-facto standard for C++ GUI development. There are open source tools (wxWidgets, Qt) and proprietary tools, but who knows what any given company uses for their software - if they even write desktop software at all anymore, anyway. Most things are HTML/CSS/JS based now. :)

  The study of Computer Science is more about how computers work rather than the design of front-ends.

  Adding a GUI layer on top of learning core C++ or about data structures can make the course content less focused and make it hard to understand the important parts on its own.

• Command line programs on your own computer
  

  If you're on Windows open up the PowerShell. If you're on Mac open up the Terminal. If you're on Linux open up your favorite Terminal emulator or whatever. :) Let's look at some basic programs that might be useful.

  • ping URL - The ping program allows us to send multiple packets to some URL. I usually just use this to see if my internet has gone down or if a site is just down. I still, by habit, use ping yahoo.com even though I haven't used Yahoo in years. (FYI: Use CTRL+C to end a command line program if it continues looping.)

  rachelwil@rachelwil-GF63-Thin-9SC:~$ ping yahoo.com
  PING yahoo.com (98.137.11.163) 56(84) bytes of data.
  64 bytes from media-router-fp74.prod.media.vip.gq1.yahoo.com (98.137.11.163): icmp_seq=1 ttl=49 time=60.6 ms
  64 bytes from media-router-fp74.prod.media.vip.gq1.yahoo.com (98.137.11.163): icmp_seq=2 ttl=49 time=63.1 ms
  64 bytes from media-router-fp74.prod.media.vip.gq1.yahoo.com (98.137.11.163): icmp_seq=3 ttl=49 time=85.4 ms
  64 bytes from media-router-fp74.prod.media.vip.gq1.yahoo.com (98.137.11.163): icmp_seq=4 ttl=49 time=69.7 ms
  ^C
  --- yahoo.com ping statistics ---
  4 packets transmitted, 4 received, 0% packet loss, time 3004ms
  

  • mkdir FOLDER1 FOLDER2 FOLDER3 - The mkdir (make-directory) program allows you to create 1 or more folders within the directory that you're currently in.
  • ls - The ls (list) program shows you all the files and folders in the directory that you're currently in.
  • pwd - The pwd (present working directory) program shows you the path of the directory that you're currently in.

  rachelwil@rachelwil-GF63-Thin-9SC:~/test-folder$ mkdir folderA folderB folderC
  
  rachelwil@rachelwil-GF63-Thin-9SC:~/test-folder$ ls
  folderA  folderB  folderC
  
  rachelwil@rachelwil-GF63-Thin-9SC:~/test-folder$ pwd
  /home/rachelwil/test-folder
  

  Commands that you can use from the terminal can also be called from C++ by using the system() function.

• See also
  
  • YouTube: Tomorrow's World: Home Computer Terminal 20 September 1967 (BBC) - Using a teletype terminal to communicate with a remote computer
  • YouTube: What are Dumb Terminals? (The 8-Bit Guy)

  Turn in: https://canvas.jccc.edu/courses/68294/modules/items/3742323

📊 Presentation - C++ basics (U03.PRES)

📖️ Reading - C++ basics (U03.READ)

• An empty C++ program
  

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

  int main()
  {
  
    return 0;
  }
  

  No matter what all is in your program, your compiler is going to expect that a main function exists, and this function acts as the starting point of a C++ program.

  The opening curly-brace { and closing curly-brace } denote the start and end of the main function. The curly-braces and any code within is known as a code-block. Program instructions will go within this code-block.

  At the end of the main function we have return 0;. In this context, it means "return (exit) the program with a status of 0", with that basically meaning "return with no errors". If you ran into an error while the program was running, you might do something like return 123; instead, to mark the area with an "error code" (123), which you can then find in the code.

  For our programs starting off, we will be putting our instruction code after the opening curly-brace { and before the return 0;, but the code given above is the absolute, bare-minimum required to write a C++ program.

  Review:

  1. What function is the starting point of every C++ program?
  2. What is a code-block?
  3. What command means the program ended with no errors?
• An introduction to syntax
  

  Context: What is syntax?

  syntax, noun

  The way in which linguistic elements (such as words) are put together to form constituents (such as phrases or clauses)

  From the Merriam-Webster Dictionary.

  C++, Java, C#, and other "C-like" languages follow similar syntax rules.

  Lines of code: A code statement ends with a semi-colon. Statements are single commands, like using cout ("console out") to display text to the screen, assigning a value to a variable, and other simple operations.

  string state;               // Variable declaration
  cout << "Enter state: ";    // Display text to screen
  cin >> state;               // Getting input from keyboard
  cout << state << endl;      // Displaying text to the screen
  

  Code blocks: There are certain types of instructions that contain additional code. If statements, for example, contain a set of instructions to execute only if the condition given evalutes to true. Any time an instruction contains additional instructions, we use opening and closing curly braces { } to contain this internal code. Note that an if statement and other structures that contain code don't end with a semicolon ;.

  Comments: Comments are notes left in the code by humans for humans. They can help us remember what our code was doing later on, or help guide someone else reading through our code. There are two ways we can write comments in C++.

  If we use // then all text afterwards will be a comment. This is a single-line comment.

  If we use /* then all text will be a comment, only ending once we reach a */. This is a multi-line comment.

  string state;               // Variable declaration
  
  /*
    Next we're going to search for this state
    in the list of all states that match xyz criteria...
  */
  

  Review:

  1. When should a line of code end with a semicolon ;, and when will it have a code block {} instead?
  2. How do you write a single-line comment?
  3. How do you write a multi-line comment?
  • Syntax errors and logic errors
    

    

    Syntax errors are errors in the language rules of your program code. This include things like typos, misspellings, or just writing something that isn't valid C++ code, such as forgetting a ; at the end of some instructions.

    Although they're annoying, syntax errors are probably the "best" type of error because the program won't build while they're present. Your program won't build if you have syntax errors.

    Logic errors are errors in the programmer's logic. This could be something like a wrong math formula, a bad condition on an if statement, or other things where the programmer thinks thing A is going to happen, but thing B happens instead.

    These don't lead to build errors, so the program can still be run, but it may result in the program crashing, or invalid data being generated, or other problems.

  • Minimizing bugs and debugging time
    

    

    • Write a few lines of code and build after every few lines - this will help you detect syntax errors early.
    • DON'T write the "entire program" before ever doing a build or a test - chances are you've written in some syntax errors, and now you'll have a long list of errors to sift through!
    • If you aren't sure where an error is coming from, try commenting out large chunks of your program until it's building again. Then, you can un-comment-out small bits at a time to figure out where the problem is.

    ---

• Review questions
  
  1. What are syntax errors?
  2. What are logic errors?

  ---

• Variables and data
  

  

  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. Holdover from ancient times when computers' outputs came via the printers.)

  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.

  • 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.

    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	variable	string password = "123secure";

    Of these, notice that the string data type doesn't have a fixed size. This is because technically, behind-the-scenes, a string is really just an array (or list) of char data types. The C++ standard library contains a string library that handles a lot of text-related functionality like find.

    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.

• Declaring variables and assigning values to variables
  

  Variable declaration

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

  1. DATATYPE VARIABLENAME;
  2. DATATYPE VARIABLENAME = VALUE;
  3. DATATYPE VARIABLENAME1, VARIABLENAME2, VARIABLENAME3;
  4. DATATYPE VARIABLENAME1 = VALUE1, VARIABLENAME2 = VALUE2;

  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.

  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;
  

  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);
  

  Variable assignment

  1. VARIABLENAME = LITERAL; - Stores the LITERAL value in VARIABLENAME.
  2. VARIABLENAME1 = VARIABLENAME2; - Copies the value from VARIABLENAME2 to VARIABLENAME1.

  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.

  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
  

  Copying student13's value to the bestStudent variable:

  bestStudent = student13;
  

  

  ---

  • Naming conventions
    

    You can name a variable anything you'd like, but it can only contain numbers, underscore (_), and upper- and lower-case letters in the name. Variable names can begin with the underscore or a letter, but they cannot start with a number. And definitely NO spaces are allowed in a variable name!

    Additionally, a variable name cannot be a keyword in C++, a name reserved for something else in the language, such as void, if, int, 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).

    One common way variables are named are using camelCasing, where each subsequent word in a variable's name is capitalized:

    int howManyCookies;
    string mySecurePassword;
    float howMuchStudentLoansIHave;
    

    Another common way you might see variables named in C++ is using underscores to split up words:

    int how_many_cookies;
    string my_secure_password;
    float how_much_student_loans_i_have;
    

    I just want you to be consistent with your style, though you can choose either one of these styles.

    ---

  • 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.

    ---

  • 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:

    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!
    

    ---

  • Basic operations on variables
    

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

    • Outputting variable values
      

      Using the cout (console-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;
      

      (We will cover more about input and output next part)

    • Inputting variable values
      

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

      cin >> favoriteColor;
      

    • Math operations
      

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

      cout << "Sum: " << num1 + num2 + num3 << endl;
      

      Operations:

      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;
      

      

      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:

      cpp

      // Long way:
      totalCats = totalCats + 5;
      
      // Compound operation:
      totalCats += 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'
      

      ---

  • 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.

    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.

    Named constant declaration format: const CONSTNAME = LITERAL; - Stores the LITERAL value in CONSTNAME.

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

    // Somewhere in the code...
    checkoutPrice = 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...
    checkoutPrice = 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.

    Named constant naming convention: In C++, it is customary to give your named constants names in ALL CAPS, using underscores (_) to separate words.

    ---

• Interactivity and Output in C++
  

  Most programs feature interactivity in some way or another. This can involve moving a mouse around, clicking on things, tapping on a touch screen, using a gamepad's joysticks and buttons, but we'll be primarily interacting with our C++ programs through keyboard input. Feedback from our C++ programs will come in the form of text output to the screen, as we are writing terminal programs.

  

  We will also delve into reading from and writing to text files (or other file formats) later on. But for now, let's focus on the terminal/console.

  

  • Outputting Information with cout
    

    The cout command (pronounced as "c-out" for "console-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.

    ---

  • 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";
    

    the output will be:

    HelloWorld
    

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

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

    And our output will be:

    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;
    

    ---

  • Inputting Information with cin
    

    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 "console-in").

    For variables like int and float, you will use this format to store data from the keyboard into the variable:

    • Using cin >> for variables
      

      cin >> VARIABLENAME;
      

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

      cin >> VARIABLENAME1 >> VARIABLENAME2 >> ETC;
      

    • 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:

      string name;
      cin >> name;
      

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

    • 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:

      string name;
      getline(cin, name);
      

    • 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 );
      

    • 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

      Example code:

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

      Output:

      "hello
      world"
      

      Example code:

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

      Output:

      A       B       C
      1       2       3
      

      Example code:

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

      Output:

      He said "Hi!" to me!
      

      ---

• Review questions
  
  1. What is the output stream operator?
  2. What is the input stream operator?

🔎 Concept Intro - C++ basics (U03.CIN)

🧑‍🔬 Lab - C++ basics (U03.LAB)

• Starter code
  

  Make sure that you have already downloaded the starter code off your repository. If you don't already have it downloaded, click on the blue "Code" button, and select "zip" to download the source code.

  

  Make sure to extract the zip file on your computer.

  The program files we're going to use are in the u03_CPPBasics folder. There are several different folders within:

  .
  ├── graded_program
  │   └── program.cpp
  ├── practice1_greeting
  │   └── greetings_v1.cpp
  ├── practice2_arguments
  │   └── greetings_v2.cpp
  ├── practice3_calc
  │   └── calc.cpp
  ├── practice4_cinstream
  │   └── perimeter.cpp
  └── practice5_getline
      └── pet.cpp
  

  Rules:

  • You can score up to 100% just by turning in the graded_program item.
  • If you turn in the practice programs as well, you will earn extra credit points.
  • Doing the practice programs are recommended.

  ---

  practice1_greeting:

  This program starts off partially written:

  // PROGRAM: Console output practice
  
  // - INCLUDES ---------------------------------------------------------------//
  #include <iostream>   // Library that contains `cout` commands
  #include <string>     // Library that contains `string` types
  using namespace std;  // Using the C++ STanDard libraries
  
  // - PROGRAM CODE -----------------------------------------------------------//
  int main()
  {
    // TODO: Update the placeholder text below, NAME, COLOR, and SOMETHING, with your own text.
  
    cout << "Hello, I'm: NAME" << endl;
    cout << "My favorite color is: COLOR" << endl;
    cout << "This semester I hope to learn about... SOMETHING" << endl;
  
    // Return 0 means quit program with no errors, in this context.
    return 0;
  }
  

  There are certain comments marked TODO that have instructions. For this assignment, you'll do the following:

  1. Replace NAME with your name
  2. Replace COLOR with your favorite color
  3. Replace SOMETHING with something you'd like to learn about

  After you've substituted the text, we're going to build and run the program.

  Open up the terminal, or power shell, within the practice1_greeting folder.

  ((TODO: ADD IMAGE))

  Build the program with g++ greetings_v1.cpp

  Then run the program with ./a.exe

  $ g++ greetings_v1.cpp
  $ ./a.exe
  Hello, I'm: Rachel
  My favorite color is: Purple
  This semester I hope to learn about... Cmake :)
  

  ---

  practice2_arguments:

  Starter code:

  // PROGRAM: Variable assignment practice
  
  // - INCLUDES ---------------------------------------------------------------//
  #include <iostream>   // Library that contains `cout` commands
  #include <string>     // Library that contains `string` types
  using namespace std;  // Using the C++ STanDard libraries
  
  // - PROGRAM CODE -----------------------------------------------------------//
  int main()
  {
    // TODO: Update the variables below to use your own text.
    string name = "NAME";
    string color = "COLOR";
    string learn_about = "SOMETHING";
  
    // You don't have to update anything here now, these output statements are using
    // the variables to get their data from!
    cout << "Hello, I'm: " << name << endl;
    cout << "My favorite color is: " << color << endl;
    cout << "This semester I hope to learn about... " << learn_about << endl;
  
    // Return 0 means quit program with no errors, in this context.
    return 0;
  }
  

  This second program is similar to the first one, except that we're using variables to store your name, favorite color, and something you'd like to learn.

  Substitute the following in this code:

  1. Replace NAME with your name
  2. Replace COLOR with your favorite color
  3. Replace SOMETHING with something you'd like to learn about

  Afterwards, build and run the program to make sure it still runs:

  $ g++ greetings_v1.cpp
  $ ./a.exe
  Hello, I'm: Rachel
  My favorite color is: Purple
  This semester I hope to learn about... Cmake :)
  

  ---

  practice3_calc:

  Starter code:

  // PROGRAM: Variable arithmetic practice
  
  // - INCLUDES ---------------------------------------------------------------//
  #include <iostream>   // Library that contains `cout` commands
  #include <string>     // Library that contains `string` types
  using namespace std;  // Using the C++ STanDard libraries
  
  // - PROGRAM CODE -----------------------------------------------------------//
  int main()
  {
  
    // Declaring variables
    float num1, num2;
  
    // Ask the user to enter num1
    cout << "Please enter num1: "; // Display prompt
    cin >> num1;                   // Get input from keyboard
  
    // Ask the user to enter num2
    cout << "Please enter num2: "; // Display prompt
    cin >> num2;                   // Get input from keyboard
  
    // Declaring more variables
    float sum, difference, product, quotient;
  
    // TODO: Assign the variable `sum` the value of `num1` plus `num2`.
  
  
    // TODO: Assign the variable `difference` the value of `num1` minus `num2`.
  
  
    // TODO: Assign the variable `product` the value of `num1` times `num2`.
  
  
    // TODO: Assign the variable `quotient` the value of `num1` divided by `num2`.
  
  
    cout << endl; // Adding more space
    cout << "ARITHMETIC:" << endl;
    cout << "SUM:        " << num1 << " + " << num2 << " = " << sum << endl;
    cout << "DIFFERENCE: " << num1 << " - " << num2 << " = " << difference << endl;
    cout << "PRODUCT:    " << num1 << " * " << num2 << " = " << product << endl;
    cout << "QUOTIENT:   " << num1 << " / " << num2 << " = " << quotient << endl;
  
    // Return 0 means quit program with no errors, in this context.
    return 0;
  }
  

  For this program, there are two float variables declared: num1 and num2. The program already contains some cin statements to get values into unm1 and num2.

  There are also four "results" float variables declared: sum, difference, product, and quotient. Under teach comment that says TODO, write down a math operation:

  1. Add num1 and num2 and store the result in the sum variable.
  2. Subtract num1 and num2 and store the result in the difference variable.
  3. Multiply num1 and num2 and store the result in the product variable.
  4. Divide num1 and num2 and store the result in the quotient variable.

  Remember that assignment statements are written in this form:

  VARIABLE = VALUE;

  After implementing it, build and test the program. If the math comes out wrong, then try to investigate your code and see if you can find a logic error.

  $ g++ calc.cpp
  $ ./a.exe
  Please enter num1: 5
  Please enter num2: 10
  
  ARITHMETIC:
  SUM:        5 + 10 = 15
  DIFFERENCE: 5 - 10 = -5
  PRODUCT:    5 * 10 = 50
  QUOTIENT:   5 / 10 = 0.5
  

  ---

  practice4_cinstream:

  Starter code:

  // PROGRAM: Console input and variable arithmetic practice
  
  // - INCLUDES ---------------------------------------------------------------//
  #include <iostream>   // Library that contains `cout` commands
  #include <string>     // Library that contains `string` types
  using namespace std;  // Using the C++ STanDard libraries
  
  // - PROGRAM CODE -----------------------------------------------------------//
  int main()
  {
    // TODO: Declare a float variable for `width`.
  
  
    // TODO: Declare a float variable for `length`.
  
  
    // TODO: Use `cout` to display a prompt - tell the user - "Enter a width: "
  
  
    // TODO: Use `cin` to get keyboard input, store in `width` variable.
  
  
    // TODO: Use `cout` to display a prompt - tell the user - "Enter a length: "
  
  
    // TODO: Use `cin` to get keyboard input, store in `length` variable.
  
  
    // TODO: Declare a float variable `perimeter`, assign it the result of `2 * width + 2 * length`.
  
  
    // TODO: Declare a float variable `area`, assign it the result of `width * length`.
  
  
    // TODO: Use `cout` to display "Perimeter:", and then the value of the `perimeter` variable.
  
  
    // TODO: Use `cout` to display "Area:", and then the value of the `area` variable.
  
  
    // Return 0 means quit program with no errors, in this context.
    return 0;
  }
  

  For this program you will do all the steps to create variables to store a rectangle's width and length, display messages to the screen, get input from the keyboard, do the math, and display the result. You can always look at the previous programs for reference as well.

  The steps are:

  1. Declare a float variable named width
  2. Declare a float variable named length
  3. Display a message to the user, saying "Enter a width:"
  4. Get input from the keyboard, store the result in the width variable
  5. Display a message to the user, saying "Enter a length:"
  6. Get input from the keyboard, store the result in the length variable
  7. Declare a float variable named perimeter, assign it the result of 2 * width + 2 * length
  8. Declare a float variable named area, assign it the result of width * length
  9. Display "Perimeter:" and then the value of the perimeter variable
  10. Display "Area:" and then the value of the area variable

  $ g++ perimeter.cpp
  $ ./a.out
  Enter a width: 4
  Enter a length: 3
  Perimeter: 14
  Area: 12
  

  ---

  practice5_getline:

  Starter code:

  // PROGRAM: cin and getline practice
  
  // - INCLUDES ---------------------------------------------------------------//
  #include <iostream>   // Library that contains `cout` commands
  #include <iomanip>    // Library for text formatting, has `setw`, `left`.`
  #include <string>     // Library that contains `string` types
  using namespace std;  // Using the C++ STanDard libraries
  
  // - PROGRAM CODE -----------------------------------------------------------//
  int main()
  {
    // ------- GET USER INPUT -------
    cout << "---- PET 1 ----" << endl;
  
    // Declaring variables
    string pet1_name;
    int    pet1_age;
    string pet1_animal;
    string pet1_breed;
  
    // Ask the user to enter information...
    cout << "Name: ";             // Display prompt
    getline( cin, pet1_name );    // Get string input
  
    cout << "Age:  ";             // Display prompt
    cin >> pet1_age;              // Get int input
    cin.ignore();                 // Flush the input buffer
  
    cout << "Animal: ";           // Display prompt
    getline( cin, pet1_animal );  // Get string input
  
    cout << "Breed: ";            // Display prompt
    getline( cin, pet1_breed );   // Get string input
  
    cout << endl << "---- PET 2 ----" << endl;
  
    // TODO: Create variables `name2`, `age2`, `animal2`, `breed2`, based on the previous example.
  
  
    // TODO: Ask the user to enter the name, age, animal, and breed for pet 2.
  
  
    // ------- DISPLAY RESULTS -------
  
    cout << left; // Set left alignment
    cout << endl; // Add more spacing
  
    const int COL1 = 7;
    const int COL2 = 20;
    const int COL3 = 7;;
    const int COL4 = 15;
    const int COL5 = 15;
  
  
    cout << "Collected information:" << endl << endl;
  
    cout << setw( COL1 ) << "PET#" << setw( COL2 ) << "NAME" << setw( COL3 ) << "AGE" << setw( COL4 ) << "ANIMAL" << setw( COL5 ) << "BREED" << endl;
    cout << string( 80, '-' ) << endl;
  
    // Pet 1:
    cout << setw( COL1 ) << "1";
    cout << setw( COL2 ) << pet1_name;
    cout << setw( COL3 ) << pet1_age;
    cout << setw( COL4 ) << pet1_animal;
    cout << setw( COL5 ) << pet1_breed;
    cout << endl;
  
  
    // TODO: Display information for pet 2
  
  
  
    // Return 0 means quit program with no errors, in this context.
    return 0;
  }
  

  This program uses the getline function to get names of pets and store them in string variables. Pet 1 is already taken care of, you just need to do the same thing for Pet 2.

  At the end of the program, Pet 1's information is displayed in a table, using the setw functions to set up columns. Follow the same formatting, and display all the information for Pet 2 as well.

  $ g++ pet.cpp
  $ ./a.out
  ---- PET 1 ----
  Name: Cyrus
  Age:  15
  Animal: Dog
  Breed: Maltese
  
  ---- PET 2 ----
  Name: Kabe
  Age:  8
  Animal: Cat
  Breed: Unknown
  
  Collected information:
  
  PET#   NAME                AGE    ANIMAL         BREED
  --------------------------------------------------------------------------------
  1      Cyrus               15     Dog            Maltese
  2      Kabe                8      Cat            Unknown
  

  ---

  graded_program:

  Starter code:

  // - INCLUDES ---------------------------------------------------------------//
  #include <iostream>   // Library that contains `cout` commands
  #include <string>     // Library that contains `string` types
  using namespace std;  // Using the C++ STanDard libraries
  
  // - STUDENT CODE -----------------------------------------------------------//
  const string YOURNAME = "Your Name, Spring 2024"; // TODO: Update this to your name!
  
  int StudentCode( int guest_count, int pizza_slices )
  {
    // The variable `guest_count` has an UNKNOWN NUMBER in it.
    // The variable `pizza_slices` has an UNKNOWN NUMBER in it.
  
    // TODO: Create an integer variable `slices_per_person`.
  
  
    // TODO: Calculate how many slices of pizza each guest gets (slices divided by guests).
    // Assign the result to the `slices_per_person` variable.
  
  
    // TODO: Use `cout` to display "Total guests:", and then the value from the `guest_count` variable.
  
  
    // TODO: Use `cout` to display "Total slices of pizza:", and then the value from the `pizza_slices` variable.
  
  
    // TODO: Use `cout` to display a message of how many slices of pizza each guest gets
  
  
    // TODO: Use the `return` keyword to return the amount of slices (e.g., `return slices_per_person;`).
    return -1; // erase this line of code!!
  }
  

  There's a lot of extra code in this program, but you don't have to worry about anything below the

  //   !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  //   !! DON'T MODIFY ANYTHING BELOW THIS POINT! !!
  //   !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  

  Basically, I've added some automated testing to test out the program, but you can also test it out manually.

  Within the program code, labeled StudentCode, we have two variables already made: int guest_count and int pizza_slices. (These are within the parentheses above. We'll learn more about functions later.)

  Beneath each TODO item, you'll add additional code. You'll need to do the following:

  1. Declare an integer varaible named slices_per_person.
  2. Calculate how many slices of pizza each guest gets, assign the result to the slices_per_person variable. (the math here is pizza_slices / guest_count.)
  3. Display "Total guests:" and then the guest_count variable.
  4. Display "Total slices of pizza:" and then the pizza_slices variable.
  5. Display "Each guest gets", then the slices_per_person, then "slices of pizza".
  6. Return the slices_per_person variable.

  In our previous programs, main() had return 0; at the end. For this special function, instead we're going to return the result of our math operation. It will look like this: return slices_per_person;. This should go before the closing curly brace }.

  Now you can build the program. I've added -o PizzaParty.exe to the end here so that the generated program is named PizzaParty.exe.

  $ g++ program.cpp -o PizzaParty.exe
  

  You can run the program, but it will complain about "NOT ENOUGH ARGUMENTS!"

  $ ./PizzaParty.exe
  argCount is 1; NOT ENOUGH ARGUMENTS!
  Run tests:      ./PizzaParty.exe test
  Run as program: ./PizzaParty.exe guest_count pizza_slices
  

  With some of the special code I added, we can add additional information when running this program. Basically, we either have to run it and provide a guest_count and pizza_slices:

  $ ./PizzaParty.exe  20 100
  Total guests: 20
  Total slices of pizza: 100
  Each guest gets 5 slices of pizza
  RESULT: 5
  

  Or we run it with the test option and it will run automated tests to check your work:

  $ ./PizzaParty.exe test
  2024-01-U03-P1-TEST; STUDENT: Your Name, Spring 2024
  
  Total guests: 50
  Total slices of pizza: 100
  Each guest gets 2 slices of pizza
  [PASS]  TEST 1, StudentCode(50, 100) = 2
  
  Total guests: 10
  Total slices of pizza: 75
  Each guest gets 7 slices of pizza
  [PASS]  TEST 2, StudentCode(10, 75) = 7
  

  The automated tests run the PizzaParty program a couple of times, first with 50 guests and 100 slices pizza, then with 10 guests and 75 slices of pizza. It checks the results that get return-ed from the StudentCode function, and if the math is right, it will show those tests as [PASS]. If the math isn't correct, it will show [FAIL] instead.

  ---

• Turning in your work:
  

  On your GitLab page, go into the u03_CPPBasics folder, and then into whichever program folder you want to update:

  

  Click on your program's .cpp file to open it, then click "Edit" and "Single file":

  

  In your code editor on your computer, select all the text (you can use CTRL+A for select all) and copy it all (CTRL+C).

  Back in the GitLab web editor, select all (CTRL+A) and then paste your changes (CTRL+V).

  

  After you've updated all the files you want to edit,

  

  go back to the c03_CPPBasics folder and copy the URL of this page.

  On Canvas, you will submit this URL to turn in the assignment:

  

🏋️ Nonogram - Nonogram B (U03.EXE.N)

🧑‍🏫 Status Update - Command line, C++ basics (U03.SUP)

💻 Project 1 (PROJ1)

-----------------------------------------------------
--           R E C I P E   P R O G R A M           --
-----------------------------------------------------

--------------------------------------------------------------------------------
 Recipe 1: Tiger Butter Candy
 From https://butterwithasideofbread.com/tiger-butter-fudge/

 INGREDIENTS
 * 11 oz Vanilla chips
 * 0.5 cup Creamy peanut butter
 * 0.5 cup Semi-sweet chocolate chips


--------------------------------------------------------------------------------
 Recipe 2: White Chocolate Peppermint Pretzels
 From https://www.twopeasandtheirpod.com/white-chocolate-peppermint-pretzels/

 INGREDIENTS
 * 35 chips Pretzel
 * 12 oz White chocolate melting wafers
 * 0.5 cup Crushed candy canes


################################################################################
# THE END #
###########

• About
  

  For this project, we are going to review what we've learned so far to create a basic Recipe Program.

  We'll be using the following skills:

  • Creating a .cpp source code file
  • Using g++ to build our .cpp code
  • Using ./ to run our built program
  • Declaring and using variables
  • Using cout to display text and variables to the screen
  • Using cin to get input from the user
  • Doing basic arithmetic

  We will cover the steps to do this in several parts. Just like writing real-world programs, we do so iteratively - we start basic, and continue adding features over time.

  ---

• How to be successful at projects
  
  • Your program should always build. Don't continue writing features if you have build errors. WORKING CODE THAT IS INCOMPLETE IS BETTER THAN "COMPLETE" BUT BROKEN CODE THAT DOESN'T EVEN RUN.
  • Implement one feature at a time. Test after implementing one feature. Work on small chunks at a time.
  • If you get stuck, you should seek solutions, such as:
    • Asking a tutor - The campus has tutors via the Academic Achievement Center.
    • Asking the instructor - You can email me, you can ask me in class, you can schedule a one-on-one time to meet via Zoom or in person.
    • Looking at example code from class videos and the example code repository.

  ---

• CS 200 topics quick reference
  

  Use this as a reference while working through your program. You might copy/paste these notes elseware or print them out to keep them handy.

  Terminal commands

  Command	What it does
  cd FOLDERNAME	Moves you into the FOLDERNAME.
  cd ..	Moves you out of the current folder.
  ls	View a LiSt of files and folders in the current directory.
  g++ FILENAME	Build a C++ file, turning source code into an executable file. Creates "a.exe" or "a.out".
  ./a.exe	Runs the executable file named "a.exe".

  C++ instructions

  Instruction	What it does
  DATATYPE VARNAME;	Declare a variable with some datatype and name.
  int my_int;	Declare an integer variable named my_int.
  float my_float;	Declare a float variable named my_float.
  string my_string;	Declare a string variable named my_string.
  my_int = 10;	Assign a value of 10 to the my_int variable.
  my_float = 9.99;	Assign a value of 9.99 to the my_float variable.
  my_string = "Hello!";	Assign a value of "Hello!" to the my_string variable.
  cout << "Hello!";	Displays "Hello!" to the screen.
  cout << my_string;	Displays the value of the my_string variable to the screen.
  cout << endl;	Adds a new line before the next cout display.
  cin >> my_float;	Gets keyboard input, stores in my_float variable.

  ---

• Setup
  
  • Make sure your computer is setup!
    

    Before we get started, you need the following things:

    • MinGW (Windows), XCode(Mac), or g++ (Linux) installed on your computer. View the 🧑‍🔬 Unit 00 Lab - Set up (U00.LAB.202401CS200) assignment for a reminder on setting up your tools.
    • A good code editor, such as Geany (https://www.geany.org/) - This is what I'll be using in my screenshots.

    ---

  • Creating a PROJECTS folder
    
    • Open your operating system's File Explorer.

    TODO add screenshots

    • Locate the folder where you are currently storing your course files (e.g., "rsingh13-cs200").
    • Create a new folder named "PROJECTS".

    ---

  • Creating our .cpp source code file
    
    • Open up your code editor, such as Geany.
    • In Geany's dropdown menu, select File, then New.

    

    • This will create a new empty file for us.

    

    • Before we get started, let's save the file. Go to File, then Save As…
    • Navigate to your "PROJECTS" folder, and save this file with the name "project1.cpp".

    

    Now we can get started on our program.

    ---

• Gathering data for the program
  

  For this program you will need to find two simple recipes online. I looked up "three ingredient desserts" to find some. Make sure to keep the pages open, we will need the information, as well as the URL to be able to cite our sources.

  These are the recipes I used:

  • https://butterwithasideofbread.com/tiger-butter-fudge/
  • https://www.twopeasandtheirpod.com/white-chocolate-peppermint-pretzels/

  You can use the same recipes if you'd like, or find other ones. I would just suggest finding something with only a few ingredients.

  ---

• Recipe program version 1 - just cout statements
  

  

  For version 1 we're only going to use cout statements to display all the recipe information.

  Start with the following empty C++ program:

  #include <iostream>
  #include <string>
  using namespace std;
  
  int main()
  {
    cout << "RECIPE PROGRAM" << endl;
  
    // ADD YOUR CODE IN HERE
  
    cout << "THE END" << endl;
    return 0;
  }
  

  The program output should look like this:

  RECIPE PROGRAM
  
  --------------------------------------------------------------------------------
   Recipe 1: Tiger Butter Candy
   From https://butterwithasideofbread.com/tiger-butter-fudge/
  
   INGREDIENTS
   * 11 oz Vanilla chips
   * 0.5 cup Creamy peanut butter
   * 0.5 cup Semi-sweet chocolate chips
  
  --------------------------------------------------------------------------------
   Recipe 2: White Chocolate Peppermint Pretzels
   From https://www.twopeasandtheirpod.com/white-chocolate-peppermint-pretzels/
  
   INGREDIENTS
   * 35 chips Pretzel
   * 12 oz White chocolate melting wafers
   * 0.5 cup Crushed candy canes
  
  THE END
  

  Make sure that the program output is easy to read and well organized. Some tips:

  • Give enough spacing between chunks of information, such as INGREDIENTS being spaced away from the URL and the "THE END".
  • Use lines of dashes or other symbols to show a physical separation between regions.
  • Make sure that the text itself is readable: 11 oz Vanilla chips is good, but 11ozVanilla chips is bad.

  Task: Implement version 1 of the Recipe Program. This version should only have cout statements to display all of the information. Check with the instructor to make sure you're on the right track if unsure.

  ---

  • Building and running your program
    

    While working through the program, you should be building your program periodically to check for syntax errors. Additionally, you should also run the program here and there to make sure the output looks correct.

    To build your program, open up the terminal from within the folder where your project1.cpp file is.

    Build the program:

    g++ program1.cpp
    

    Run the program:

    ./a.exe
    

    (or a.out on Linux/Mac)

    ---

  • Backing up your work before continuing
    

    Backing up your work periodically is important, whether you need to step back after encountering big errors and see what changed since last time, or just making sure your work isn't lost in case of a power outage. We will back up our current version of the code on our GitLab page.

    • Go to your GitLab repository and click on the "PROJECTS" folder.

    

    • No files are here yet. Click on the "+" button, then click "Upload new file".

    

    • Locate your project1.cpp file on your computer. You can either click-and-drag it to the dotted box, or click on the dotted box to locate the file via the file browser.

    

    • Add a commit message like "Project 1 version 1". Then click the "Upload file" button to finish.

    Now you can return to your code editor (like Geany) and start on version 2.

    ---

• Recipe program version 2 - variables
  

  

  • Creating variables
    

    For version 2 we're going to add in variables. We will need a lot of variables to store all of the recipe information! Make sure your variables are clear and descriptive so that your code is easy to read.

    Here is a table of all the variables you will need. I am also including the values I used for the recipes I used, but you can change the variable values to your own recipes.

    Variable name	Data type	My variable values
    RECIPE 1
    recipe1_name	string	"Tiger Butter Candy"
    recipe1_url	string	"https://butterwithasideofbread.com/tiger-butter-fudge/"
    recipe1_ingredient1_amount	float	11
    recipe1_ingredient1_name	string	"Vanilla chips"
    recipe1_ingredient1_unit	string	"oz"
    recipe1_ingredient2_amount	float	0.5
    recipe1_ingredient2_name	string	"Creamy peanut butter"
    recipe1_ingredient2_unit	string	"cup"
    recipe1_ingredient3_amount	float	0.5
    recipe1_ingredient3_name	string	"Semi-sweet chocolate chips"
    recipe1_ingredient3_unit	string	cup"
    RECIPE 2
    recipe2_name	string	"White Chocolate Peppermint Pretzels"
    recipe2_url	string	"https://www.twopeasandtheirpod.com/white-chocolate-peppermint-pretzels/"
    recipe2_ingredient1_amount	float	35
    recipe2_ingredient1_name	string	"Pretzel"
    recipe2_ingredient1_unit	string	"chips"
    recipe2_ingredient2_amount	float	12
    recipe2_ingredient2_name	string	"White chocolate melting wafers"
    recipe2_ingredient2_unit	string	"oz"
    recipe2_ingredient3_amount	float	0.5
    recipe2_ingredient3_name	string	"Crushed candy canes"
    recipe2_ingredient3_unit	string	cup"

    Variables need to be declared before they're used in a C++ program, so I would suggest that you create the variables at the top of the program:

    #include <iostream>
    #include <string>
    using namespace std;
    
    int main()
    {
      // DECLARE VARIABLES HERE
    
      cout << "RECIPE PROGRAM" << endl;
    
      // DISPLAY RECIPE INFORMATION HERE
    
      cout << "THE END" << endl;
      return 0;
    }
    

    (Note: You're not starting from scratch with this version, the above code is just an example of where each section of the program should go.)

    ---

  • Updating your cout statements
    

    Now that we have variables set up, you'll need to update your cout statements to use these variables instead of the hard-coded information from v1.

    For example, in version 1, display the recipe name and url might look like this:

    cout << " Recipe 1: Tiger Butter Candy" << endl << endl;
    cout << " From https://butterwithasideofbread.com/tiger-butter-fudge/" << endl << endl;
    

    And the update for version 2 might look like this:

    cout << " Recipe 1: " << recipe1_name << endl;
    cout << " From " << recipe1_url << endl << endl;
    

    Do this for all your recipe information - name, url, ingredient amount, name, and unit.

    Make sure your program still looks nice afterwards, it should still be readable and clear. The output should look the same, we haven't changed the interface yet, just how the data is stored in the program.

    Make sure you're building and running the program to test as you go!

    ---

  • Backing up your work before continuing
    

    Backing up your work periodically is important, whether you need to step back after encountering big errors and see what changed since last time, or just making sure your work isn't lost in case of a power outage. We will back up our current version of the code on our GitLab page.

    • Go to your GitLab repository and click on the "PROJECTS" folder.

    

    • Our "project1.cpp" file should be here. Click on it.

    

    • Click on the "Edit" button, then click "Edit single file".

    

    • Copy your C++ code from your "project1.cpp" file on your computer, and paste it into this editor window on GitLab. At the bottom of this page, add a commit message like "Project 1 version 2". Then click the "Commit changes" button to finish.

    

    Now you can return to your code editor (like Geany) and start on version 3.

    ---

• Recipe program version 3 - arithmetic
  

  

  For this final version we are going to ask the user how many batches they'd like to make. The user can enter something like 1 for a normal batch, 0.5 for half batch, 2 for double batch, and so on.

  We will do this at the start of the program so that, once the recipes are displayed, we can update the ingredient amounts to show an updated value.

  #include <iostream>
  #include <string>
  using namespace std;
  
  int main()
  {
    // CREATE A batches VARIABLE
  
    // ASK THE USER HOW MANY BATCHES THEY WANT TO MAKE
  
    // GET THEIR INPUT AND STORE IT IN THE batches VARIABLE
  
    // DECLARE VARIABLES HERE
  
    cout << "RECIPE PROGRAM" << endl;
  
    // DISPLAY RECIPE INFORMATION HERE
    // MULTIPLY EACH INGREDIENT AMOUNT BY THE batches VARIABLE
  
    cout << "THE END" << endl;
    return 0;
  }
  

  ---

  • How many batches?
    

    At the top of the program, we'll want to do the following:

    1. Declare a new float variable. Its name should be batches.
    2. Display a message to the user using the cout command. Ask: How many batches to make?
    3. Get input from the keyboard using the cin >> command. Store the user's answer in the batches variable.

    ---

  • Updating ingredient amounts
    

    Further down in the program where you're displaying all the ingredient's information, you'll need to update your amounts shown to now be multiplied by the batches variable.

    For example, in version 2, an ingredient display might have looked like:

    cout << recipe1_ingredient1_amount
      << " " << recipe1_ingredient1_unit
      << " of " << recipe1_ingredient1_name << endl;
    

    And the update for version 3 might look like this:

    cout << recipe1_ingredient1_amount * batches
      << " " << recipe1_ingredient1_unit
      << " of " << recipe1_ingredient1_name << endl;
    

    Do this for all the ingredient amounts.

    ---

  • Program output
    

    Once implemented, your program should look something like this:

    How many batches would you like to make? 2
    
    -----------------------------------------------------
    --           R E C I P E   P R O G R A M           --
    -----------------------------------------------------
    
    --------------------------------------------------------------------------------
     Recipe 1: Tiger Butter Candy
     From https://butterwithasideofbread.com/tiger-butter-fudge/
    
     INGREDIENTS
     * 22 oz Vanilla chips
     * 1 cup Creamy peanut butter
     * 1 cup Semi-sweet chocolate chips
    
    
    --------------------------------------------------------------------------------
     Recipe 2: White Chocolate Peppermint Pretzels
     From https://www.twopeasandtheirpod.com/white-chocolate-peppermint-pretzels/
    
     INGREDIENTS
     * 70 chips Pretzel
     * 24 oz White chocolate melting wafers
     * 1 cup Crushed candy canes
    
    
    ################################################################################
    # THE END #
    ###########
    

    It doesn't have to match exactly and you can customize the style as you'd like, as long as it remains readable.

    ---

  • Backing up your work before continuing
    

    Once again, back up your work to GitLab:

    1. Go to your GitLab repository and click on the "PROJECTS" folder.
    2. Click on your "project1.cpp" file.
    3. Click on the "Edit" button, then click "Edit single file".
    4. Copy and paste your code from "project1.cpp" on your computer into the editor on GitLab.
    5. Add a "commit message" like "Project 1 FINAL VERSION".
    6. Click "Commit changes" to finish.

    We're not done with GitLab yet, let's look around before finishing up the assignment.

    ---

• Exploring your file's history
  
  • From your file's page on GitLab, click on the "History" button.

  

  • This shows a list of all the changes you've made to this file, including those commit messages that describe what was updated.

  

  • Click on your "Project 1 version 2" update. You'll see lines of code marked in green (for added) or red (for removed). This can be useful to see what all changed since your last updates.

  

  ---

• Turning in the assignment
  
  • On the GitLab webpage go to your "project1.cpp" file. Copy the URL of this file.

  

  • On Canvas, locate the "💻 Project 1 (PROJ1.202401CS200)" assignment. Click on "Start Assignment".
  • Paste the URL to your "project1.cpp" file on GitLab and click "Submit Assignment" to complete the assignment.

  

  Turn in: https://canvas.jccc.edu/courses/68294/modules/items/3907325

📊 Presentation - Control flow (U04.PRES)

📖️ Reading - Control flow (U04.READ)

• Boolean expressions
  

  In order to start writing questions that a computer can understand, we need to understand boolean expressions.

  A math expression looks like this:

  \[ 2 + 3 \]

  A boolean expression is a statement that result in either true or false:

  "it is daytime."

  "the user saved the document"

  "the user's age greater than 12 and less than 20"

  

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

  Logic in computer programs are based around these types of questions: something that can only be true or false. Statements include:

  • Is [boolean variable] true?

    x
    

  • Is [boolean variable] false?

    !x
    

  • Are two variables equal?

    x == y
    

  • Are two variables not equal?

    x != y
    

  • Is x less than y?

    x < y
    

  • Is x less than or equal to y?

    x <= y
    

  • Is x greater than y?

    x > y
    

  • Is x greater than or equal to y?

    x >= y
    

  For the first two, we can check the value of a boolean variable. The rest of them, we can use any data type to compare if two values are equal, greater than, less than, etc. a and b can be replaced with variables and/or values…

  if ( age < 18 ) { ... }
  
  if ( my_state == your_state ) { ... }
  
  if ( word1 < word2 ) { ... }
  
  if ( document_saved == true ) { ... }
  
  if ( document_saved == false ) { ... }
  

  Note: 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).

  ---

  • And, Or, and Not operators
    

    We can also combine boolean expressions together to ask more sophisticated questions.

    • Not operator: !
      

      If we're checking a boolean variable, or a boolean expression, and we happen to want to execute some code for when that result is false, we can use the not operator…

      Using with boolean variable *documentSaved:*

      // Just checking documentSaved = true
      if ( documentSaved )
        {
        Quit();
      }
      
      // Checking if documentSaved = false with the not operator
      if ( !documentSaved )
      {
        Save();
        Quit();
      }
      

      Using with boolean expressions *( age >= 21 ):*

      // If the age is not 21 or over...
      if ( !( age >= 21 ) )
      {
        NoBeer();
      }
      

      ---

    • And operator: &&
      

      When using the and operator, we can check to see if all boolean variables/expressions are true. The full question of "is this and this and this true?" only results to true if all boolean variables/expressions are true. If even one of them are false, then the entire statement is false.

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

      To break it down, the customer would only get beer if they want beer AND if they are over 21. If they don't want beer but are 21 or over, they don't get beer. If they want beer but are under 21, then they don't get beer.

      ---

    • Or operator: ||
      

      For an or operator, we can check to see if at least one boolean variable/expression is true. If at least one item is true, then the whole statement is true. The only way for it to be false is when each boolean variable/expression is false.

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

      In this case, discounts are given to babies, seniors, and vets. A customer wouldn't have to be all three to qualify (and clearly, couldn't be all three at the same time!). If the customer is not a baby and not a senior and not a vet, then they don't get the discount - all three criteria have to be false for the entire expression to be false.

      ---

  • 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.

    ---

    • 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

      ---

    • 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.

      For example, 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. gameSaved is true and wantToQuit is true: Quit the game. ✅
      2. gameSaved is true and wantToQuit is false: The user doesn't want to quit; don't quit. ❌
      3. gameSaved is false and wantToQuit is true: The user wants to quit but we haven't saved yet; don't quit. ❌
      4. gameSaved is false and wantToQuit is false: The user doesn't want to quit and the game hasn't been saved; don't quit. ❌

      ---

    • Truth table for OR:
      

      Generic form:

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

      Again, if at least one of the expressions is true, then the entire expression is true.

      Example: 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. hasCake is true and hasIcecream is true: The store has desserts; suggest it to the user. ✅
      2. hasCake is true and hasIcecream is false: The store has cake but no ice cream; suggest it to the user. ✅
      3. hasCake is false and hasIcecream is true: The store has no cake but it has ice cream; suggest it to the user. ✅
      4. 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. ❌

      ---

  • 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"!

    ---

    • 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.

      ---

    • 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.

      ---

  • 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.

    

    ---

• Branching
  

  Branching is one of the core forms of controlling the flow of the program. We ask a question, and based on the result we perhaps do this code over here or maybe that code over there - the program results change based on variables and data accessible to it.

  We will mostly be using if / else if / else statements, though switch statements have their own use as well. Make sure to get a good understanding of how each type of branching mechanism "flows".

  ---

  • If statements
    

    If statements (usually the general term encompassing if / else if / else as well) are a way we can ask a question and respond: If \(a\) is less than \(b\) then… or if \(a\) is greater than \(c\) then… Otherwise do this default thing…

    Let's look at some examples while ironing out how it works.

    • If statements
      

      For a basic if statement, we use the syntax:

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

      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:

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

      Output with balance = -50

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

      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.

      ---

  • If/Else statements
    

    In some cases, we will have code that we want to execute for the false result as well. For an if/else statement, either the if code block will be entered, or the else code block will be.

    NOTE: The else statement NEVER has a CONDITION.

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

    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.

    Example:

    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.

    ---

  • 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.

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

    Example:

    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;
    

    With this example, I'm first checking if the grade is 90 or above. If it is, then I know the letter grade is 'A'.

    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, that means grade < 90. Since the next statement checks if grade > 80=, if this one is true I know that grade < 90 AND grade > 80=.

    ---

• While loops
  

  While loops look a lot like if statements…

  while ( CONDITION )
  {
    // Do stuff repeatedly
  }
  

  except that they will continue looping while their condition is true. Once the condition results in false, then the loop will stop and the program will continue after the while loop's code block.

  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!

  The while loop's condition is another boolean expression - a statement that will be true or false.

  ---

  Example: Counting up

  The following while loop will increase a variable by 1 each time and display it to the screen.

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

  Output:

  1	2	3	4	5	6	7	8	9
  

  ---

  Example: 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;
  

  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
  

  ---

  Example: Program loop

  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;
  

  ---

• 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 );
  

  ---

• Special commands
  
  • 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;
      }
    

    Output:

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

    ---

  • 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
          }
      }
    

    ---

• Switch statements
  

  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:
  
  // is equivalent to...
  
  if ( VARIABLE == VALUE1 ) {
  

  case VALUE2:
  
  // is equivalent to...
  
  if ( VARIABLE == VALUE2 ) {
  

  default:
  
  // is equivalent to...
  
  else {
  

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

  ---

  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.

  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 ( opreation == '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;
  

  Note: 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;
  }
  

  ---

• Review questions:
  
  1. A boolean expression can be…
  2. What do each of these expressions represent?
     1. b
     2. !b
     3. a = b=
     4. a > b
     5. a = b
  3. What are each of the following operators?
     1. &&
     2. ||
     3. !
  4. When does the expression a && b evaluate to true? false?
  5. When does the expression when a || b evaluate to true? false?
  6. An if statement's code block will be executed when the if statement's condition evaluates to…
  7. A while loop's code block will continue executing while the while loop's condition evaluates to…

🔎 Concept Intro - Control flow (U04.CIN)

🧑‍🔬 Lab - Control flow (U04.LAB)

$ cd FOLDERNAME

$ ls
graded_program_1  practice2_ifelse     practice5_switch
graded_program_2  practice3_ifelseif   practice6_while_program
practice1_if      practice4_operators

g++ SOURCE.cpp

.\a.exe

./a.out

// PROGRAM: Practice if statements

// - INCLUDES ---------------------------------------------------------------//
#include <iostream>   // Library that contains `cout` commands
#include <string>     // Library that contains `string` types
#include <iomanip>    // Library for formatting; `setprecision`
using namespace std;  // Using the C++ STanDard libraries

// - PROGRAM CODE -----------------------------------------------------------//
int main()
{
  cout << fixed << setprecision( 2 ); // Format floats like USD

  // TODO: Create three float variables: `balance`, `withdraw`, and `remaining`.

  // TODO: Use `cout` to prompt the user to enter information and `cin` to get information from the keyboard.
  // Get user's input for `balance` (their current bank balance) and `withdraw` (how much to withdraw from bank).

  // TODO: Calculate the `remaining` balance after the withdraw with `remaining = balance - withdraw;`

  // TODO: Display "Remaining balance: $" and the `remaining` variable.

  // TODO: If `remaining` is less than 0, then also display "(OVERDRAWN)".

  // Return 0 means quit program with no errors, in this context.
  return 0;
}

Enter your current balance: $40
Enter how much to withdraw: $200
Remaining balance: $-160.00 (OVERDRAWN)

Enter your current balance: $100
Enter how much to withdraw: $80
Remaining balance: $20.00

// PROGRAM: Practice if/else statements

// - INCLUDES ---------------------------------------------------------------//
#include <iostream>   // Library that contains `cout` commands
#include <string>     // Library that contains `string` types
using namespace std;  // Using the C++ STanDard libraries

// - PROGRAM CODE -----------------------------------------------------------//
int main()
{
  // TODO: Create an integer `number` variable. Ask the user to enter a value for the number.

  // TODO: If number is greater than 0, then display "Positive number". Otherwise, display "Negative or zero".

  // Return 0 means quit program with no errors, in this context.
  return 0;
}

Enter a number: 6
Positive number

Enter a number: 0
Negative or zero

Enter a number: -5
Negative or zero

// PROGRAM: Practice if/else if statements

// - INCLUDES ---------------------------------------------------------------//
#include <iostream>   // Library that contains `cout` commands
#include <string>     // Library that contains `string` types
using namespace std;  // Using the C++ STanDard libraries

// - PROGRAM CODE -----------------------------------------------------------//
int main()
{
  // TODO: Create an int variable named `charge`.

  // TODO: Use `cout` to tell the user to enter their battery charge %.

  // TODO: Use `cin` to get their input and store it in the `charge` variable.

  // TODO: Use if/else if/else statements to decide which battery image to draw.
  // 90% and above: [****];  75% and above: [***-];  50% and above: [**--];  25% and above: [*---];  below 25%: [----]

  // Return 0 means quit program with no errors, in this context.
  return 0;
}

Enter the battery charge: %50
Image: [**__]

Enter the battery charge: %95
Image: [****]

// PROGRAM: Practice using logic operators

// - INCLUDES ---------------------------------------------------------------//
#include <iostream>   // Library that contains `cout` commands
#include <string>     // Library that contains `string` types
using namespace std;  // Using the C++ STanDard libraries

// - PROGRAM CODE -----------------------------------------------------------//
int main()
{
  // TODO: Create two boolean variables, `has_paper` and `printer_on`.

  // TODO: Display the message "Is the printer on? (0) off, (1) on: ";

  // TODO: Use `cin` to get keyboard input and store it in `printer_on`.

  // TODO: Display the message "Does the printer have paper? (0) no paper, (1) has paper: ";

  // TODO: Use `cin` to get keyboard input and store it in `has_paper`.

  // TODO: If has_paper is true and printer_on is true then display "CAN PRINT!"
  // Otherwise, display "CANNOT PRINT!".

  // Return 0 means quit program with no errors, in this context.
  return 0;
}

Is the printer on? (0) off, (1) on: 0
Does the printer have paper? (0) no paper, (1) has paper: 0
CANNOT PRINT!

Is the printer on? (0) off, (1) on: 1
Does the printer have paper? (0) no paper, (1) has paper: 1
CAN PRINT!

Is the printer on? (0) off, (1) on: 0
Does the printer have paper? (0) no paper, (1) has paper: 1
CANNOT PRINT!

Is the printer on? (0) off, (1) on: 1
Does the printer have paper? (0) no paper, (1) has paper: 0
CANNOT PRINT!

// PROGRAM: Practice using switch statements

// - INCLUDES ---------------------------------------------------------------//
#include <iostream>   // Library that contains `cout` commands
#include <string>     // Library that contains `string` types
using namespace std;  // Using the C++ STanDard libraries

// - PROGRAM CODE -----------------------------------------------------------//
int main()
{
  // TODO: Create two string variables, `english` and `translated`. Initialize `english` to "cat".

  // TODO: Create a character variable named `language`. Ask the user to enter a language letter,
  // and store their response in this variable.

  // TODO: Use a switch statement to look at the `language` chosen.
  // In case of 'e', set `translated` to "kato".
  // In case of 's', set `translated` to "gato".
  // In case of 'm', set `translated` to "mao".
  // In case of 'h', set `translated` to "billee".
  // For the default case, set `translated` to "?"

  // TODO: Display the `english` word and then `translated` word.`

  // Return 0 means quit program with no errors, in this context.
  return 0;
}

(e)speranto, (s)panish, (m)andarin, (h)indi
Enter a language letter: e
cat = kato

(e)speranto, (s)panish, (m)andarin, (h)indi
Enter a language letter: h
cat = billee

// PROGRAM: Practice creating a program loop with while

// - INCLUDES ---------------------------------------------------------------//
#include <iostream>   // Library that contains `cout` commands
#include <string>     // Library that contains `string` types
using namespace std;  // Using the C++ STanDard libraries

// - PROGRAM CODE -----------------------------------------------------------//
int main()
{
  bool running = true;
  int choice;

  while ( running ) // Keep program running until `running` is false.
    {
      // Display MENU
      cout << "-- MAIN MENU --" << endl;
      cout << "1. Display my favorite book" << endl;
      cout << "2. Display my favorite movie" << endl;
      cout << "3. Display my favorite game" << endl;
      cout << "4. Exit program" << endl << endl;

      // GET USER SELECTION
      cout << "SELECTION: ";
      cin >> choice;
      cout << "You chose " << choice << endl;

      // PERFORM OPERATION
      // TODO: Use a switch statement or an if statement here.
      // Option 1: Display your favorite book.
      // Option 2: Display your favorite movie.
      // Option 3: Display your favorite game.
      // Option 4: Set `running` to false, which will cause the program to quit.
      // Any other inputs: Display "unknown command!"

      cout << endl;
    }

  cout << endl << "GOODBYE" << endl;
  // Return 0 means quit program with no errors, in this context.
  return 0;
}

-- MAIN MENU --
1. Display my favorite book
2. Display my favorite movie
3. Display my favorite game
4. Exit program

SELECTION: 1
You chose 1
Masters of Doom

-- MAIN MENU --
1. Display my favorite book
2. Display my favorite movie
3. Display my favorite game
4. Exit program

SELECTION: 2
You chose 2
The Lost Skeleton of Cadavra

-- MAIN MENU --
1. Display my favorite book
2. Display my favorite movie
3. Display my favorite game
4. Exit program

SELECTION: 3
You chose 3
Divinity Original Sin 2

-- MAIN MENU --
1. Display my favorite book
2. Display my favorite movie
3. Display my favorite game
4. Exit program

SELECTION: 4
You chose 4

GOODBYE

char StudentCode( float points_possible, float my_score )
{
  char letter_grade = 'F';

  // TODO: Create a float for `grade_percent`. Calculate the percent with `my_score` divided by `points_possible` times 100.


  // TODO: Use if/else if/else statements to determine value for `letter_grade` based on the `grade_percent`;
  // 89.5 and above = A, 79.5 and above = B, 69.5 and above = C, 59.5 and above = D, below that is F.


  // TODO: Display grade information, including `my_score`, `points_possible`, `grade_percent`, and `letter_grade`.


  // TODO: Return the `letter_grade` as the result.
  return letter_grade;
}

1. Run AUTOMATED TESTS
2. Run PROGRAM
>> 2
Enter points possible: 80
Enter your score: 75

GRADE INFORMATION
My score ......... 75.00
Points possible ...80.00
Grade % ...........93.75
Letter grade ......A

RESULT: A

int StudentCode( float starting_salary, float raise_per_year, int years )
{
  float updated_salary = starting_salary;

  cout << "Starting salary: $" << starting_salary << endl;

  int current_year = 1;

  // TODO: Use a loop, you need to create a counter variable that goes from 1 to `years`.
  // Within the loop, calculate the updated salary with
  // `updated_salary = updated_salary + ( updated_salary * raise_per_year );`
  // Use `cout` to display the year (counter) and the `updated_salary` each iteration.
  // Make sure to add 1 to current_year each iteration through the loop.


  // TODO: Return the `updated_salary` as the result.
  return updated_salary;
}

1. Run AUTOMATED TESTS
2. Run PROGRAM
>> 2
Enter starting salary: 30000
Raise per year: %3
Enter how many years to project: 5
Starting salary: $30000.00
Year: 1, Salary: $30900.00
Year: 2, Salary: $31827.00
Year: 3, Salary: $32781.81
Year: 4, Salary: $33765.26
Year: 5, Salary: $34778.22
RESULT: $34778.00

• Turning in your work
  
  1. Go to your GitLab webpage.
  2. Select the folder for this unit in the main view. Locate the file you want to update and click on it.

  3. Click on the blue "Edit" button, then click "Edit single file".

     

  4. COPY your work off your computer and PASTE it into the web editor on GitLab. Scroll to the bottom of the page and click "Commit changes" to finish up.

  5. Go back to the unit folder and COPY the URL for this unit.

     

  6. On Canvas, locate the assignment. Click "Start assignment".

  7. Paste the copied URL into the box and click "Submit assignment".

     

🧠 Tech Literacy - Filesystems (U04.TEC)

• Before computers
  

  

  Figure 14: Photo by Mike: https://www.pexels.com/photo/depth-of-field-photography-of-file-arrangement-1181772/

  Before computers were widely available to businesses and at home, long-term storage of information was often stored in physical folders organized by some method (alphabetical, purpose, etc.).

  Within each folder there would be files, such as contracts, filled out forms, and so on. Anything we do on a computer now had to be done on paper before.

  While working on a file, people would work at their desk - on their desktop. That's where work in progress items would go.

  If you haven't noticed the similarity yet, a lot of computer terminology about navigating our computers come from these office environments. When computers were first created, there was a lot of things named based on real-world items, as a way to give an "analogy" for what the software did.

  ---

• Files and folders
  
  • Files
    

    

    On our computers we we files where we store data. This can be any type of data - text, images, video, music files, code files, and so on.

    Each file at least has a name and a size associated with it, and usually files are given different extensions to help the Operating System understand what kind of file it is.

    

    File extension	File type
    .mp3	Music file
    .csv	Comma-separated value table
    .jpg	JPEG image file (good for photos)
    .png	PNG image file (good for low color images)
    .html	HTML document (opened by web browsers)

    Files have contents - the data it is storing within. For a plain text file, it'd just be text information:

    

    For an image file, its contents is data about the image itself - what color is at each position.

    

    Some file types are technically plaintext, but the way their contents are written signify different things. An HTML webpage can be opened in a text editor:

    

    And a C++ program's code can be opened in a text editor:

    

    These are both plaintext files, but we put ".html" at the end to specify a basic HTML webpage, or ".cpp" at the end to specify that this file is C++ source code.

    When you double-click a file to open it, the Operating System may look at the file extension (.html, .cpp, .mp3, etc.) to figure out which program to open it with: A music player won't do much good with a .html file, and an image viewer won't know how to read a .mp3 file.

  • Folders
    

    

    A folder represents a location on your hard drive. A folder can contain files adn other folders as well. The folders within a folder are called subfolders.

    All together, all the folders on your computer make up a tree structure…

    Diagram of an example filesystem:

    

    A screenshot of several folders opened up on my computer:

    

    Folders are also known as directories, so when we talk about what directory we're working in, that means what folder are we currently working in.

    ---

• The directory tree
  
  • Paths to documents
    

    As we traverse deeper into our filesystem tree, we grow and grow our path. The path is the string that shows the sequence of folders to follow to get to where we're currently at. The path is similar to a URL to get to a website. Both use slashes like "/" to separate between "folders".

    On a Windows computer, we might access our documents with a path like this:

    C:\Users\USERNAME\Documents\

    Or on Linux and Mac, it might look like this:

    /home/USERNAME/Documents/

    

    We can type in the path to the folder want to get to in the "address bar" in our file explorer, or we can double-click on folders to get into each one and go folder by folder.

    It can sometimes be useful to highlight and copy a folder path so that we can easily point projects to a new directory or for other reasons.

    ---

• Discussion board
  

  Find the "🧠 Tech Literacy - Filesystems" assignment on Canvas and participate in the discussion board!

🏋️ Nonogram - Nonogram C (U04.EXE.N)

🧑‍🏫 Status Update - Control flow (U04.SUP)

📊 Presentation - Structs (U05.PRES)

📖️ Reading - Structs (U05.READ)

• 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.

  ---

  • 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).

    ---

  • 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 wan tto 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.

    ---

• Separate variables to one 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:

  MenuItem.h:

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

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

  main.cpp:

  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;
  

  ---

• 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:

  #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.

  ---

• Creating our own structs
  

  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.

  ---

  • 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;
    

    ---

  • 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;
    

    ---

  • 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:

    main.cpp:

    #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;
    }
    

    ---

• Review questions:
  
  1. File guards are needed because…
  2. What kind of data would be good to represent with a struct?
     • A character in a video game including the amount of experience points they have, their current hit points, and current level
     • The tax rate of a city
     • The URL of a website you're visiting
     • An address, including recipient name, street address, city, state, and zip code
  3. If we declared an object variable like Course cs200; , How would we assign "cs" to the department member variable and 200 to the code member variable?

🔎 Concept intro - Structs (U05.CIN.202401CS200)

🧑‍🔬 Lab - Structs (U05.LAB)

$ cd FOLDERNAME

$ ls
graded_program_1  practice2_ifelse     practice5_switch
graded_program_2  practice3_ifelseif   practice6_while_program
practice1_if      practice4_operators

g++ *.cpp *.h

.\a.exe

./a.out

---- PET 1 ----
Name: Kabe
Age:  9
Animal: Cat
Breed: Gray

---- PET 2 ----
Name: Luna
Age:  5
Animal: Cat
Breed: Tuxedo7

Collected information:

PET#   NAME                AGE    ANIMAL         BREED
--------------------------------------------------------------------------------
1      Kabe                9      Cat            Gray
2      Luna                5      Cat            Tuxedo

struct Pet
{
  string name;
  int age;
  string animal;
  string breed;
}; // ; is required at the end of a struct declaration

Pet pet1;

// Ask the user to enter information...
cout << "Name: ";             // Display prompt
getline( cin, pet1.name );    // Get string input

cout << "Age:  ";             // Display prompt
cin >> pet1.age;              // Get int input
cin.ignore();                 // Flush the input buffer

cout << "Animal: ";           // Display prompt
getline( cin, pet1.animal );  // Get string input

cout << "Breed: ";            // Display prompt
getline( cin, pet1.breed );   // Get string input

BREAD RECIPE

Ingredients
 * 4.5 Cups of Flour
 * 1 Tablespoons of Sugar
 * 2.25 Teaspoons of Instant Yeast
 * 1.66 Cups of Water
 * 2.5 Teaspoons of Table Salt

string ingredient1_name = "Flour";
string ingredient1_unit = "Cups";
float  ingredient1_amount = 4.5;

Ingredient ing1;
ing1.name = "Flour";
ing1.unit = "Cups";
ing1.amount = 4.5;

Enter room's width: 5
Enter room's length: 7
RESULT:
 * width:     5
 * length:    7
 * area:      35
 * perimeter: 24

struct Room
{
  float width;
  float length;
  float area;
  float perimeter;
};

Room StudentCode( float width, float length )
{
  Room my_room;

  // TODO: Finish setting up my_room

  return my_room;
}

• Turning in your work
  
  1. Go to your GitLab webpage.
  2. Select the folder for this unit in the main view. Locate the file you want to update and click on it.

  3. Click on the blue "Edit" button, then click "Edit single file".

     

  4. COPY your work off your computer and PASTE it into the web editor on GitLab. Scroll to the bottom of the page and click "Commit changes" to finish up.

  5. Go back to the unit folder and COPY the URL for this unit.

     

  6. On Canvas, locate the assignment. Click "Start assignment".

  7. Paste the copied URL into the box and click "Submit assignment".

     

🏋️ Unit 05 Debugging - Debugging review - C++ basics (U05.EXE.D)

🏋️ Nonogram - Nonogram D (U05.EXE.N)

🧑‍🏫 Unit 05 Status Update - Structs (U05.SUP)

📊 Presentation - Functions (U06.PRES)

📖️ Reading - Functions (U06.READ)

• Program Structure
  

  

  As programs become more sophisticated and offer more features, the size of the program increases. At some point, it becomes too complicated to keep your entire program just within main().

  (You could certainly do it, but maintaining it would be a nightmare!)

  One of the tools we use to build modular, easier-to-read code is functions. By using functions, we can delegate tasks out to other portions of the program, passing inputs as data to the function, and receiving some kind of output as a result.

  As a basic example, let's say we need to calculate square footage of a room in multiple places in a program. By making a float GetArea( float width, float length ) function.

  Then, we only have to implement the formula once and can use the function in every part of the program. Then, we wouldn't be copy-and-pasting the same formula over and over again in the code - which also means less likelihood of errors, and easier to update later as needed.

  Program flow and functions

  Whenever a function is called, the program flow is redirected into that function, running from top-to-bottom as normal (with branching and loops changing that flow). Once the function has completed, it can return some data, which is received by the call location.

  From a design standpoint, this means we can break out different parts of programs into their own sections. Each function has a name, which should be used to label what the purpose of its code is.

  

  

  ---

• Function Basics
  
  • Uses of functions
    

    Functions for formulas

    In algebra, you've seen functions like this:

    \[ f(x) = 2x + 3 \]

    If you were like me in algebra, you might have thought to yourself, "That's the same as \(y = 2x + 3\), why did we replace \(y\) with \(f(x)\)?"

    The reason is that we want to write a function in terms of its input, \(x\), and its output \(f(x)\). The equation \(2x + 3\) is the function body, which specifies how we get some output given some input.

    We can use functions in programming like with math as well - defining formulas that we might need a lot - but there's more to functions than just making computations.

    Let's say we want to make our "GetArea" function in math. We would need two inputs: Width and Length, and the output would end up being the area, so maybe we would name the function \(A\). It might look like this:

    \[ A( w, l ) = w \cdot l \]

    In C++, it would look like this:

    float Area( float width, float length )
    {
      return width * length;
    }
    

    (Luckily we don't have to restrict ourselves to single-letter variable and function names in C++ :)

    ---

    Functions to validate

    Functions can also be handy in validating data and user input, putting the validation in one place instead of having to re-implement the same checks over and over.

    For example, let's say we want to keep some variable percentage in our program betwee 0% and 100% - no negative values, nothing over 100%. We could implement a function that takes the percentage as an input, and either returns the same percentage, or 0%, or 100% as output…

    int BoundPercent( int originalPercent )
    {
      if ( originalPercent < 0 )
        {
          return 0;
        }
      else if ( originalPercent > 100 )
        {
          return 100;
        }
      else
        {
          return originalPercent;
        }
    }
    

    Then, anywhere in the program, we could use this function to make sure our percentages are in the right range…

    // in main()
    hungerPercent       = BoundPercent( hungerPercent );
    healthPercent       = BoundPercent( healthPercent );
    happinessPercent    = BoundPercent( happinessPercent );
    

    

    ---

    Functions to get input

    Getting user input is a common part of writing software, and we will usually need to validate what the user is entering prior to doing any operations on it. Let's say your program is full of numbered menus and you want to validate the user's menu choices easily. You can use a function with a while loop in it:

    int GetUserInput( int min, int max )
    {
      int choice;
      cout << "Choice: ";
      cin >> choice;
    
      while ( choice < min || choice > max )
        {
          cout << "Invalid choice, try again: ";
          cin >> choice;
        }
    
      return choice;
    }
    

    You write this function once and then you can reuse it in your entire program for all menus…

    cout << "1. Deposit money" << endl
         << "2. Withdraw money" << endl
         << "3. View balance" << endl;
    
    choice = GetUserInput( 1, 3 ); // 1, 2, or 3
    
    if ( choice == 1 )
      {
        cout << "1. Checking account" << endl
             << "2. Savings account" << endl;
    
        choice = GetUserInput( 1, 2 ); // 1 or 2
      }
    

    ---

    Functions to output

    Functions aren't required to return data. Sometimes, you just want a function that is responsible for formatting output or displaying a menu. In this case, a function's return type can be void.

    void DisplayStudentInfo( string name, float gpa )
    {
      cout << "Name:   " << name
           << "GPA:    " << gpa << endl;
    }
    

    You also aren't required to pass input to functions. In this case, the parameter list between ( ) remains empty, but the () is always required for functions:

    void DisplayMainMenu()
    {
      cout << "1. Deposit" << endl;
      cout << "2. Withdraw" << endl;
      cout << "3. View Balance" << endl;
      cout << "4. Log Out" << endl;
    }
    

    ---

    Other uses

    These are just some examples of why you might use functions in your programs. Anything you write in main() can go inside of a different function as well - it's just another tool for designing clean, maintanable, and readable code.

    

    ---

  • Anatomy of a function
    
    • Function Declaration
      

      float GetArea( float width, float height );
      

      Before you start using a function, you have to declare and define it… A function declaration is similar to a variable declaration - we tell the program "hey, we want to use this function, here's its name and some info about it." Declaration statements end with a semi-colon and don't contain a code block (the function body) because it's just a declaration.

      Function Header: The function header is the first line of a function, which includes the following information: return type, function name, and parameter list.

      RETURNTYPE FUNCTIONNAME( PARAM1TYPE PARAM1NAME, ... )
      

      • Function Return Type: The return type of a function specifies what kind of data is returned from this function. The return type can be any data type, or it can be void if nothing is going to be returned.
      • Function Name: The function name should describe what the responsibility of the function is - what it does.
      • Function Parameters: The parameters of a function are a list of input variables that are expected to be passed into the function from elseware. The parameter list is located between the ( and ) in the function header.

      ---

    • Function Definition
      

      float GetArea( float width, float height )
      {
        return width * height;
      }
      

      The function definition is where we actually write what the function does. It includes the same information as the function declaration, but we include the function body in a code block.

      ---

    • Function Body
      

      The function body is the code block, written between { and }, defining what logic the function performs.

      ---

    • Function Call
      

      float room1Sqft = GetArea( 5, 10 );
      float room2Sqft = GetArea( room2width, room2length );
      

      After a function is defined, we can then call that function to execute its internal code. If the function has input parameters, we can pass in literal values (hard-coded data) or variables to provide that input data.

      ---

      Calling a function

      Once the function has been defined, you can call it from anywhere in your program…

      int main()
      {
        float width, height;
        cout << "Enter width and height: ";
        cin >> width >> height;
      
        // Call GetArea
        float area = GetArea( width, height );
      
        cout << "Area: " << area << endl;
      }
      

      Function Call: Calling a function requires the function name, and passing in a series of inputs that become the function's parameters. In the example above, the GetArea function is called, with the values from the width and height variables being passed in. Once GetArea returns its output, that output is then stored in the area variable.

      Arguments: An argument is the name of the value or variables being passed into the function during the function call. These arguments become the values that the function parameters within the function definition uses.

      Here in the function call, 10 and 20 are the arguments:

      // Call GetArea
      float area = GetArea( 10, 20 );
      

      So the values of 10 and 20 get used as the width and length parameters' values:

      float GetArea( float width, float height )
      {
        return width * height;
      }
      

      The arguments of a function call can be hard-coded values, like 10 and 20 above, or you can pass in other variables as arguments. Then, whatever is stored in those variables is copied over to the parameters.

      // Call GetArea twice
      float area1 = GetArea( room1Width, room1Length );
      float area2 = GetArea( room2Width, room2Length );
      

      The arguments passed in do not need to share a name with the parameters; these are not the same variables. They're only sharing the data stored within them.

      The first time GetArea is called, whatever is stored within room1Width is copied from that variable and stored in the parameter variable width within the function's definition.

      Common function errors:

      1. When you're declaring/defining a function you specify data types - the return type and the parameters' data types. When you're calling a function, you do not include data types!
         • YES: sqft = GetArea( room_width, room_length );
         • NO: sqft = GetArea( float room_width, float room_length );
      2. Functions must have parentheses ()! If you're missing the parentheses, your program isn't going to call the function!
         • YES: DisplayMenu();
         • NO: DisplayMenu;
      3. If a function contains a return statement, then you must store the returned data in a variable! If you don't assign the return anywhere, it will be lost!
         • YES: sqft = GetArea( room_width, room_length );
         • NO: GetArea( room_width, room_length );

      ---

• Variable scope
  

  Scope refers to the location in the code where a variable exists.

  main():

  If you declare a variable at the top of the main() function, not inside any if statements or loops, then that variable is in scope for the entire duration of main(), starting with the line it was declared on.

  int main()
  {
    int a;
    // ...etc...
  }
  

  ---

  Variables declared within if statements and loops:

  Variables declared within the code block of an if statement or a loop only exists within that code block.

  if ( a == 3 )
  {
      int b;  // only exists within this block
  }
  
  for ( int i = 0; i < 10; i++ )
  {
      cout << i; // only exists within this block
  }
  

  If you try to use these variables somewhere below the code block, your compiler will give an error, stating that the variable does not exist in that scope. Once the program leaves the code block, the variable is out of scope.

  ---

  Functions:

  Remember that main() is a function, just like any other functions we write in our program. Any variables declared within a function are local to that function, and accessible anywhere from the variable's declaration until the end of the function.

  int GetChoice()
  {
    int choice; // local variable
    cout << "Choice: ";
    cin >> choice;
    return choice;
  }
  

  ---

  Parameters:

  Variables declared in the parameter list of a function are also local to that function and can be used anywhere within the function.

  int Sum( int a, int b, int c )
  {
  // a, b, and c are local to this function.
  return a + b + c;
  }
  

  ---

  Same names?

  The same name can be reused for different variables in different scopes. Even if they share the same name, they are not related in any way.

  int GetChoice()
  {
    int choice;     // Variable A
    cout << "Choice: ";
    cin >> choice;
    return choice;
  }
  
  int main()
  {
    int choice;     // Variable B
    choice = GetChoice();
  }
  

  ---

• Parameters and arguments
  
  • Pass-by-value
    

    When we have a function declared with a parameter…

    void Example( int someNumber )
    {
      cout << someNumber;
    }
    

    …and we call that function elseware, passing in another variable as an argument…

    int main()
    {
      int myNumber = 2;
      Example( myNumber );
      return 0;
    }
    

    … What happens is that the value of the variable myNumber is copied and passed to the function parameter someNumber. This works the same as if you simply pass in Example( 10 ), passing in a hard-coded value instead of using a variable.

    If you wrote the function to change the value of its parameter, that change would only be reflected within the function and would not affect the original argument passed as part of the function call.

    void Example( int someNumber )
    {
      cout << "Example begin: " << someNumber << endl;
      someNumber = 100;
      cout << "Example end: " << someNumber << endl;
    }
    
    int main()
    {
      int myNumber = 2;
    
      Example( myNumber );
    
      cout << "main end: " << myNumber << endl;
    
      return 0;
    }
    

    The output of this program would be:

    Example begin: 2
    Example end: 100
    main end: 2
    

    Even though the value of someNumber from the Example function changes (which is valid), that change doesn't affect myNumber within main(), because only the value was copied over.

    This is known as pass-by-value.

    ---

  • Pass-by-reference
    

    If we wanted to change the value of an argument variable within a function, we'd have to change the parameter to pass-by-reference. To do this, we use the symbol = &= in the parameter's declaration, after the data type and before the variable name.

    void Example( int& someNumber )
    {
      cout << "Example begin: " << someNumber << endl;
      someNumber = 100;
      cout << "Example end: " << someNumber << endl;
    }
    

    The ampersand symbol can go next to the data type (int & blah), next to the variable name (int &blah), or separate from both (int & blah).

    Once we've made the parameter a reference, then when the function is called, the argument is not copied - a reference to that variable is passed to the function. Any changes to the reference parameter in the function also affects the original argument variable.

    int main()
    {
      int myNumber = 2;
    
      // Calling it looks the same as before
      Example( myNumber );
    
      cout << "main end: " << myNumber << endl;
    
      return 0;
    }
    

    The output of this program would be:

    Example begin: 2
    Example end: 100
    main end: 100
    

    ---

    Pass-by-reference instead of return

    In some cases, you may need to return multiple pieces of data from a function - however, you can only return one item from a function with the return statement (in C++). One option is to set the information you want "returned" as pass-by-reference parameters of the function.

    void DoubleTheseNumbers( int & a, int & b, int & c )
    {
      a *= 2;
      b *= 2;
      c *= 2;
    }
    

    ---

    Pass-by-reference of large things

    We haven't gone over arrays or classes/objects yet, but another reason we might want to pass something by-reference instead of by-value is when the parameter is big (which can be the case with arrays and objects).

    If we have a large object we need to pass to a function, doing a copy of the entire thing is inefficient - it is much simpler and faster to pass the large object by-reference.

    

    ---

  • Summary: Ways to pass data to/from functions
    

    The following table illustrates different ways we can define our parameters, and what the goal is. "RT" means "Return Type", "T" is the "Type" of the parameter.

    #	Function	Read	Return	Info
    1.	RT func( T X )	yes	no	Pass-by-value X
    2.	RT func( const T& X )	yes	no	Const pass-by-reference X
    3.	RT func( T& X )	yes	yes	Pass-by-reference X

    1. X is pass-by-value, which is fine for primitive data types like ints, floats, chars, and bools.
    2. X is passed by const-reference because X is a mose sophisticated data type like a string or other class-based object. (Longer time to copy if passed by value.)
    3. The function can read from X but also overwrite its value and the change will be reflected back to the argument being passed to the function call.

    ---

• Default parameters
  

  When declaring a function, you can also set default parameters. These are the default values assigned to the parameters if the user doesn't pass anything in. The default parameters are only specified in a function declaration - NOT the definition!

  In this example, it could be a function that displays ingredients for a recipe, and by default the batch is set to 1.0 (one batch).

  void OutputIngredients( float eggs, float sugar, float flour, float batch = 1.0 );
  

  The function could be called without passing in a batch:

  cout << "Ingredients:" << endl;
  OutputIngredients( 1, 2.0, 3.5 );
  

  Or they could pass a batch amount explicitly:

  cout << "Ingredients:" << endl;
  OutputIngredients( 1, 2.0, 3.5, 0.5 );  // half batch
  

  You can have multiple default parameters specified in your function declaration - but all variables with default values must go after any variables without default values.

  ---

• Function Overloading
  

  In C++, you can also write multiple functions that have the same name, but a different parameter list. This is known as function overloading.

  Let's say you want to be able to sum numbers, and you make a version for floats and a version for integers:

  int Sum( int a, int b )
  {
    return a + b;
  }
  
  float Sum( float a, float b )
  {
    return a + b;
  }
  

  You can write as many versions of the function as you like, so long as the function headers are uniquely identifiable to the compiler, which means:

  • The functions have a different amount of parameters, or
  • The data types of the parameters are different, or
  • The parameters are in a different order (when mixing data types).

  These will become much more useful once we cover classes and objects.

  ---

• Review questions:
  
  1. Build the function signature given the following specs:
     • The function is named "GetRectArea".
     • The function returns a float.
     • The function takes in a float for the width and a float for the length
  2. Identify each code snippet (function declaration / definition / call):

     • a.

       float PercentToDecimal( float percent )
       {
           return percent / 100.0;
       }
       

     • b.

       float   PercentToDecimal( float percent );
       

     • c.

       float decimal = PercentToDecimal( percent );
       

  3. Identify how the following parameters are passed (by value / by reference), given this function declaration:

     void SomeFunction( int& a, int b );
     

     • a is passed…
     • b is passed…

🔎 Concept Intro - Functions (U06.CIN)

🧑‍🔬 Lab - Function (U06.LAB)

• Practice programs
  

  Program documentation is inside the source files.

  Practice	Location	Starter code
  practice 1: DisplayMenu function	u06_Functions/practice1_NoInNoOut/	program1.cpp
  practice 2: DisplayFormattedUSD function	u06_Functions/practice2_YesInNoOut/	program2.cpp
  practice 3: GetTaxPercent function	u06_Functions/practice3_NoInYesOut/	program3.cpp
  practice 4: GetPricePlusTax function	u06_Functions/practice4_YesInYesOut/	program4.cpp

  ---

• Graded program: Purchase program
  

  ########################################
  PURCHASE CALCULATOR
  
  Current transaction amount: $0.00
  1. Add item 	 2. Checkout
  Enter a number between 1 and 2: 1
  Enter price of new item: $2.50
  
  Current transaction amount: $2.50
  1. Add item 	 2. Checkout
  Enter a number between 1 and 2: 1
  Enter price of new item: $4.56
  
  Current transaction amount: $7.06
  1. Add item 	 2. Checkout
  Enter a number between 1 and 2: 2
  
  RECEIPT
   * Transaction total: $7.06
   * Tax rate:          %9.61
   * After tax:         $7.74
  RESULT: 7.74
  

  This project has several files, but you only need to make updates in a couple of them.

  • Program.cpp: contains main() (I've already written this)
  • Tester.cpp: contains the automated tests (I've already written this)
  • Functions.h: contains the function declarations (I've already written these)
  • Functions.cpp: contains the function definitions (you will update these)

  Within Functions.h update the YOURNAME string with your name.

  ---

  Updating the Function Definitions in Functions.cpp:

  You can copy the DisplayMenu, FormatUSD, GetTaxPercent, and GetPricePlusTax functions from the practice programs. (Look at the practice programs for the requirements for these functions.)

  There are a few new functions as well.

  ---

  float GetNewPrice():

  1. Create a float variable to store a new price.
  2. Ask the user to enter the price of the new item.
  3. Get their input and store it in your float variable.
  4. return your float variable at the end.

  ---

  int GetChoice( int min, int max ):

  1. Create an integer variable to store the user's input.
  2. Ask the user to enter a number.
  3. Get their input and store it in your integer variable.
  4. WHILE their input is less than min OR greater than max, do:
     1. Display an error message ("Outside valid range!")
     2. Get the user's input again and store it in your integer variable (the same one).
  5. After the while loop, return the user's input variable.

  ---

  float StudentCode():

  This will be where the main program lives.

  Quick reference: How to call the functions that we'll be working with:

  Function name	Declaration	Inputs	Outputs	Example call
  DisplayMenu	void DisplayMenu();	none	none	DisplayMenu();
  GetChoice	int GetChoice( int min, int max );	min, max	the user's choice	choice = GetChoice(1, 2);
  GetNewPrice	float GetNewPrice();	none	a price	price = GetNewPrice();
  DisplayFormattedUSD	void DisplayFormattedUSD( float );	a price	none	FormatUsd( var );
  GetTaxPercent	float GetTaxPercent();	none	the tax percent	tax = GetTaxPercent();
  GetPricePlusTax	float GetPricePlusTax( float, float );	price, tax	the updated price	newprice = GetPricePlusTax( price, tax );

  How to implement this function: Follow each step linearly, starting from the top of the StudentCode function.

  • Make sure you have the following variables declared here:

  Variable	Type	Value
  final_price	float
  transaction_total	float
  new_price	float
  running	bool	true
  choice	int

  • Create a while loop to keep the program running until the user decides to quit: while ( running ) { }
  • Within the while loop do the following:
    • Display "Current transaction amount:"
    • Call the DisplayFormattedUSD function, passing in the transaction_total. (DON'T use a cout on this line!)
    • Call the DisplayMenu function.
    • Call the GetChoice function passing in 1 and 2 as the arguments. Store the return data in the choice variable.
    • If choice is 1:
      1. Call the GetNewPrice function and store its return data in the new_price variable.
      2. Add new_price to the transaction_total, making sure to update the transaction_total's value.
    • Otherwise if choice is 2:
      1. Set running to false so that the loop will end and the program will continue.
  • After the while loop is over, display the text "RECEIPT".
  • Call the GetPricePlusTax function, passing in transaction_total and GetTaxPercent() as its arguments. Store its return data in the final_price funnction.
  • Display "Transaction total:".
  • Call DisplayFormattedUSD, passing in the transaction_total. (DO NOT USE cout HERE.)
  • Display "Tax rate:", then call GetTaxPercent(), all in one cout statement.
  • Display "After tax:".
  • Call the DisplayFormattedUSD function, passing in the final_price. (Do not use cout here.)
  • Finally, return the final_price at the end of this function.

  ---

• Turning in your work
  

  Go to the GitLab webpage, locate the file you want to update, and click the blue "Edit" button, then click "Edit single file". Paste in your changes and click the "Commit changes" at the bottom of the page. Copy the URL to the file or unit folder and paste it in as your submission on the Canvas assignment.