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

Table of Contents

\newpage

topic-corecompsci.png

Rachel Wil Sha Singh's Core C++ Course Β© 2024 by Rachel Wil Sha Singh is licensed under CC BY 4.0. To view a copy of this license, visit http://creativecommons.org/licenses/by/4.0/

These course documents are written in emacs orgmode and the files can be found here: https://gitlab.com/moosadee/courses

Dedicated to a better world, and those who work to try to create one.

\newpage

l1-contents.png

This section contains each of the units we will be covering in the class, including the reading material, review, and assignment documentation. Add your own notes and highlight things as you go through!

WEEK 1 - JAN 22

topic-setup.png

UNIT 00: Welcome & setup

πŸ…°οΈ Pre-test (PRETEST.202401.CS200)

❓ Unit 00 Setup - GitLab Username

πŸ“–οΈ 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.

    u00_WelcomeAndSetup_gatekeepingbaby.png

    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.

    u00_WelcomeAndSetup_justwork.png

    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.

    u00_WelcomeAndSetup_buildingblocks.png

    Roadmap

    u00_WelcomeAndSetup_roadmap.png

    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.

    u00_WelcomeAndSetup_search.png

    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?

    hit-computer.png

    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)

Overview:
Students will set up a GitLab account, be given access to a repository, and practice uploading files. Additionally, students will also set up a Compiler and Text Editor and practice Compiling and Running some example C++ code.
Turn-in:
  • 1. A set of screenshots with certain steps completed:
    • For WINDOWS users:
      • The MinGW bin folder directory on your hard-drive.
      • Your Updated Environment Variables pointing to MinGW.
    • ALL STUDENTS:
      • The cs200 folder unzipped on your hard-drive.
      • Building the test-program.cpp using g++ from the PowerShell or other Shell/Terminal.
      • Running the a.out program using ./ in the PowerShell or other Shell/Terminal.
  • 2. A link (URL) to your u00_Welcome folder in your repository.
  • 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.

    creating_a_gitlab_account_register.png

    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.

    creating_a_gitlab_account_gotoprofile.png

    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.

    creating_a_gitlab_account_viewprofileurl.png

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

    accessing_your_gitlab_repo_repoview.png

    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.

    gitlab_download_zip.png

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

    gitlab_zip_windows.png

    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.

      mingw_webpage.png

      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.

      mingw_install1.png

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

      mingw_install2.png

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

      mingw_install3.png

      mingw_install4.png

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

      mingw_install5.png

      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.

      mingw_path.png

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

      windows_envar1.png

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

      windows_envar2.png

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

      windows_envar3.png

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

      windows_envar4.png

      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.

      installing_compiler_synaptic.png

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

    openterminal1.png

    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.

    terminal_build_cpp.png

    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:

    terminal_run_cpp.png

    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:

    terminal_build_cpp2.png

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

    gitlab_web_editfile1.png

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

    gitlab_web_editfile2.png

    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.

    gitlab_web_editfile3.png

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

    gitlab_web_upload1.png

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

    gitlab_web_upload2.png

    Your file will now be in the repository.

    gitlab_web_upload3.png

    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.

    gitlab_web_editfile5.png

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

    canvas-start2.png

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

    canvas-submit.png

    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.

UNIT 01: Exploring software

πŸ“–οΈ 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).

    c2_u01_inputoutput.png

    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.

      c2_u01_variables.png

      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:

      c2_u01_branching.png

      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.

      c2_u01_looping.png

      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

    c2_u01_debugging2.png

    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.202401CS200)

🧠 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

    tec01_ExploringSoftware_vic20.png

    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.

    tec01_ExploringSoftware_vic20box.jpg

    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

    tec01_ExploringSoftware_Macintosh.png

    Figure 8: Original Apple Macintosh desktop sample, unattributed (File:Apple_Macintosh_Desktop.png)

    tec01_ExploringSoftware_Windows.png

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

    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

    tec01_ExploringSoftware_Phone.png

    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.

    tec01_ExploringSoftware_Burger.png

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

How to play: Each cell in the grid of squares can either have a X (or blank) or be filled in. The filled in boxes create the pixels of an image. Each row and each column have one or more numbers. This specifies how many pixels are in that row/column. The number given is how many unbroken pixels will show up together. Two numbers separated by a space, e.g., "1 1", will have at least one empty spot between them.

nonogram-01.png

Hint: Among Us

nonogram-02.png

Hint: Star

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

πŸ§‘β€πŸ« Status Update - Welcome, Setup, Exploring Software (U01.SUP.202401CS200)

WEEK 2 - JAN 29

UNIT 02: Command line

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

    Used_Punchcard_(5151286161).jpg

    Figure 11: By Pete Birkinshaw from Manchester, UK - Used Punchcard, CC BY 2.0, index.php?curid=49758093Used_Punchcard_(5151286161).jpg

    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.

    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.

    vic20.jpg

    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

UNIT 03: C++ basics

πŸ“–οΈ 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

      c2_u01_debugging2.png

      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

      coding-strategy.png

      • 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

    c2_u01_variables.png

    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;
    

    c2_u01_assignment1.png


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

        c2_u01_cats.png

        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.

    c2_u01_terminal.png

    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.

    c2_u01_terminal-hi.png

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

πŸ§‘β€πŸ”¬ Lab - C++ basics (U03.LAB)

Assignment
This assignment has several small C++ programs that you will implement, following along with the instructions.
Goals
  • Practice with creating C++ programs
  • Practice with declaring and using variables
  • Practice with using cout to display text
  • Practice with using cin to get input
Turn-in
Once finished, you will upload your code to GitLab, and submit the URL to the Unit 03 folder. Canvas link: https://canvas.jccc.edu/courses/68294/modules/items/3901100

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

    lab_u03_CPPBasics_StarterCode1.png

    Make sure to extract the zip file on your computer.

    The program files we're going to use are in the u03CPPBasics 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:

    lab_u03_CPPBasics_Turnin1.png

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

    lab_u03_CPPBasics_Turnin2.png

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

    lab_u03_CPPBasics_Turnin3.png

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

    lab_u03_CPPBasics_Turnin4.png

    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:

    lab_u03_CPPBasics_Turnin5.png

πŸ‹οΈ Nonogram - Nonogram B (U03.EXE.N)

How to play: Each cell in the grid of squares can either have a X (or blank) or be filled in. The filled in boxes create the pixels of an image. Each row and each column have one or more numbers. This specifies how many pixels are in that row/column. The number given is how many unbroken pixels will show up together. Two numbers separated by a space, e.g., "1 1", will have at least one empty spot between them.

nonogram-03.png

Hint: Happy

nonogram-04.png

Hint: Cat

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

πŸ§‘β€πŸ« Status Update - Command line, C++ basics (U03.SUP.202401CS200)

WEEK 3 - FEB 5

Project 1

πŸ’» 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.


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

      project1_geanynewfile.png

      • This will create a new empty file for us.

      project1_geanyemptyfile.png

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

      project1_geanysavefile.png

      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:

    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

    project1_diagram1.png

    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.

      project1_backup1.png

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

      project1_backup2.png

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

      project1_backup3.png

      • 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

    project1_diagram2.png

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

      project1_backup1.png

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

      project1_backup4.png

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

      project1_backup5.png

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

      project1_backup6.png

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


  • Recipe program version 3 - arithmetic

    project1_diagram3.png

    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.

    project1_gitlabexplore1.png

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

    project1_gitlabexplore2.png

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

    project1_gitlabexplore3.png


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

    project1_turnin1.png

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

    project1_turnin2.png

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

WEEK 4 - FEB 12

UNIT 04: Control flow - Branching and looping

πŸ“–οΈ 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"

    reading_u03_CPPBasics_cat.png

    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 T

        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 T

        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.

      reading_u04_ControlFlow_evilbug.png


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

πŸ§‘β€πŸ”¬ Lab - Control flow (U04.LAB)

What we're gonna do:

  • Practice with if statements
  • Practice with switch statements
  • Practice with for loops

Using the command line:

Navigate to your folder using the cd (change directory) command:

$ cd FOLDERNAME

View what files are in the current folder using the ls (list) command:

$ ls
graded_program_1  practice2_ifelse     practice5_switch
graded_program_2  practice3_ifelseif   practice6_while_program
practice1_if      practice4_operators

Build your source code using the g++ compiler:

g++ SOURCE.cpp

Run your program using ./ (Linux/Mac) or .\ (Windows):

  • Windows:
.\a.exe
  • Linux/Mac:
./a.out

practice1_if: If statement

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

Program inputs: initial balance, withdraw amount

Variable Description
withdraw How much money the user wishes to withdraw from their account
balance How much money is currently in their bank account

Program outputs: remaining balance

Scenario Output Criteria
1. Balance: $-160 (OVERDRAWN) Updated balance is less than 0
2. Balance: $20 Updated balance is 0 or greater

Program logic:

  • Create three float variables for the following:
    • Initial balance (balance)
    • Withdraw amount (withdraw)
    • Remaining balance (remaining)
  • Ask the user to enter their initial balance and the withdraw amount. Store their responses in your created variables.
  • Calculate the remaining balance, which will be balance - withdraw. Store the result in your remaining balance variable remaining.
  • Display the remaining balance to the screen.
  • If the remaining balance is less than 0, then also display "OVERDRAWN".

Example output:

Withdrawing $200 from a $40 balance:

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

Withdrawing $80 from a $100 balance:

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

practice2_ifelse: If/else statement

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

Program inputs:

Variable Description
number Some integer value

Program outputs:

Scenario Output Criteria
1. positive The number passed in is greater than 0
2. zero or negative The number passed in is 0 or below

Program logic:

Given the number passed into the program, use an if/else statement to determine whether it is either (A) POSITIVE or (B) ZERO OR NEGATIVE. Return either "positive" or "zero or negative".

Tips:

  • You don't need an "else if" statement here; the else executes if the if statement is false… The opposite of \(x > y\) is \(x \leq y\).

Example output:

Passing in a 6:

Enter a number: 6
Positive number

Passing in a 0:

Enter a number: 0
Negative or zero

Passing in a -5:

Enter a number: -5
Negative or zero

practice3_ifelseif: If/else if/else statement

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

Program inputs:

Variable Description
charge What % charge someone's phone has

Program outputs:

Scenario Output Criteria
1. Battery drawing A "drawing" of the battery based on the % charge

Program logic:

DESCRIPTION

  • Create a variable to store the user's battery charge.
  • Ask the user to enter how much charge their phone battery has, and store their response in the charge variable.
  • Use if and else if statements to decide which image to draw.
Charge % Drawing
90% and above [****]
75% and above [***-]
50% and above [**--]
25% and above [*---]
Below 25% [----]

Tips:

  • You can use an "else" statement for the last case - if none of the if or else if statements are triggered, then else will catch any other results.

Example output:

Half battery:

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

Full battery:

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

practice4_operators: Logic operators AND and OR

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

Program inputs:

Variable Description
has_paper Whether the printer has paper
printer_on Whether the printer is on

Program outputs:

Scenario Output Criteria
1. Can print? Only displays "can print" if printer is on and has paper. Otherwise, displays "cannot print".

Program logic:

  • Create variables for has_paper and printer_on, these should be boolean variables.
  • Ask the user to answer yes (1) or no (0) for each of the variables ("Is the printer on?", "Does it have paper?")
  • Use an if statement with the AND operator (&&) with the condition: If the printer is on AND it has paper… Then display "CAN PRINT!"
  • Use an else statement in response… When the above isn't true, then display "CANNOT PRINT!"

Tips:

  • The logical opposite of a && b is !a || !b

Example output:

No power, no paper:

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

Yes power, yes paper:

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

No power, yes paper:

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

Yes power, no paper:

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

practice5_switch: Switch statement

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

Program inputs:

Variable Description
language Which language to translate the word to

Program outputs:

Scenario Output Criteria
1. Translated word "kato", "gato", "mao", "billee", or "?"

Program logic:

  • Create two string variables, english and translated. Initialize english to "cat".
  • Create a char variable called language. Ask the user to enter a language letter and store their response in this variable.
  • Use a switch statement to look at the language char. Based on its value, set translated to one of the values below.
  • After the switch statement, display the english word and the translated word to the screen.
Letter Language Translation
'e' Esepranto "kato"
's' Spanish "gato"
'm' Mandarin Chinese "mao"
'h' Hindi "billee"
Others   "??"

Tips:

  • Unfortunately we can't use accented characters directly in our program, it may work on certain systems automatically (Linux, Mac?) but not everything (Windows). Usually, we need to include special libraires to work with extended letter sets.

Example output:

Esperanto translation:

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

Hindi translation:

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

Practice: While loop - program loop

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

Description:

This program continues running while the running variable is set to true. This allows the user to select multiple options without having to re-run the program.

The program contains a main menu of commands they can select from, and will do something different for each command.

Program logic:

Use if/else if statements or a switch statement to investigate the value of the choice variable. Do different operations based on what its value is…

choice value output
1 Display your favorite book
2 Display your favorite movie
3 Display your favorite game
4 Set running to false
others Display "Unknown command!"

Example output:

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

Graded Program 1: Grade

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

Program inputs:

Variable Description
points_possible The amount of points an assignment is worth
my_score The amount of points the user earned on the assignment

Program outputs:

Scenario Output Criteria
1. Corresponding letter grade 'A', 'B', 'C', 'D', or 'F'

Program logic:

  • Create a float to store the grade_percent. The calculation is \[g = \frac{s}{p} \cdot 100\], where \(g\) is the grade percent, \(s\) is the user's score, and \(p\) is points possible.
  • Use if/else if statements to determine the letter grade. Use the table below for the data.
  • Display the grade information, such as my_score, points_possible, grade_percent, and the letter grade.
  • At the end, make sure you have return letter_grade; to return the result.

Automated tests:

When you run the program it will ask if you want to run the AUTOMATED TESTS or the PROGRAM. You can run the automated tests to check your work, and run the program to manually check your work.

Example output:

Program output:

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

Graded Program 2: Raise

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

Program inputs:

Variable Description
starting_salary The salary the user currently has
raise_per_year The raise they get per year (as a decimal amount… percent/100)
years The amount of years to calculate their updated salary

Program outputs:

Scenario Output Criteria
1. updated_salary The salary after years years' worth of raise_per_year.

Program logic:

  • Create a while loop. The condition is: Continue looping while the current_year is less than or equal to years. Within the loop do the following:
    • Calculate the year's adjusted salary: \[u = u + ( u \cdot r )\] Where \(u\) is the updated salary and \(r\) is the raise per year. Each update we want to overwrite the updated_salary to match the current year's updates.
    • Display the current_year and updated_salary.
    • Increment current_year by 1 before the end of the while loop.
  • After the loop is over, make sure return updated_salary; is returned.

Tips:

  • "Increment VARIABLENAME" means to add 1 to the variable, and replace the variable's value with that update.
    • Short way: a++; will add 1 to a
    • Long way: a = a + 1; will do the same thing.

Use the automated tests to validate your work, and run the program manually to test further.

Example output:

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

      gitlab_web_editfile2.png

    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.

      gitlab_web_editfile5b.png

    6. On Canvas, locate the assignment. Click "Start assignment".
    7. Paste the copied URL into the box and click "Submit assignment".

      canvas-submit.png

🧠 Tech Literacy - Filesystems (U04.TEC)

  • Before computers

    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

      tec_u04_Filesystems_File.png

      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.

      tec_u04_Filesystems_FileScreenshot.png

      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:

      tec_u04_Filesystems_TextDocument.png

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

      tec_u04_Filesystems_PngDocument.png

      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:

      tec_u04_Filesystems_HtmlDocument.png

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

      tec_u04_Filesystems_CppDocument.png

      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

      tec_u04_Filesystems_Folder.png

      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:

      tec_u04_Filesystems_Tree.png

      A screenshot of several folders opened up on my computer:

      tec_u04_Filesystems_FolderTree.png

      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/

      tec_u04_Filesystems_TreeView.png

      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)

How to play: Each cell in the grid of squares can either have a X (or blank) or be filled in. The filled in boxes create the pixels of an image. Each row and each column have one or more numbers. This specifies how many pixels are in that row/column. The number given is how many unbroken pixels will show up together. Two numbers separated by a space, e.g., "1 1", will have at least one empty spot between them.

nonogram-05.png

Hint: Love

nonogram-06.png

Hint: :P

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

πŸ§‘β€πŸ« Status Update - Control flow (U04.SUP.202401CS200)

WEEK 5 - FEB 19

UNIT 05: Structs

πŸ“–οΈ Reading - Structs (U05.READ)

  • Introduction to objects

    reading_u05_Structs_menuitems.png

    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

    reading_u05_Structs_structfiles.png

    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)

What we're gonna do:

  • Practice with declaring struct object variables
  • Practice with accessing member variables
  • Practice with writing our own struct declaration

Using the command line:

Navigate to your folder using the cd (change directory) command:

$ cd FOLDERNAME

View what files are in the current folder using the ls (list) command:

$ ls
graded_program_1  practice2_ifelse     practice5_switch
graded_program_2  practice3_ifelseif   practice6_while_program
practice1_if      practice4_operators

Build ALL SOURCE code files using the g++ compiler:

g++ *.cpp *.h

Run your program using ./ (Linux/Mac) or .\ (Windows):

  • Windows:
.\a.exe
  • Linux/Mac:
./a.out

practice1_struct: Pet store program

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

This program contains two files: Pet.h and pet_store.cpp. Our struct declarations go in header files, which end with the ".h" file extension.

Within Pet.h, a struct is already declared:

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

And within pet_store.cpp, one pet is already created:

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

For this assignment, create a second pet (struct object variable), fill out its information (member variables), and display its information afterwards. Use the first pet as a reference.


practice2_struct: Recipe ingredients

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

Within the Ingredient.h file, create a Struct named Ingredient that contains the following member variables:

Ingredient  
- name : string
- unit : string
- amount : float

Remember that a struct declaration must have a semicolon ; on its closing curly brace }!

Within the recipe.cpp file, a bunch of variables are already created:

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

You'll replace each set of variables with a single Ingredient variable instead, and update its member variables:

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

Further down in the program there are cout statements that display all the data. You will have to remove the old variables (ingredient1_name) and replace them with the new variables (ing1.name) as well.


Graded program: Room builder

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

Within the Room.h file, a Room struct has been declared:

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

You'll work in the room_builder.cpp file. Within the StudentCode function, it starts by creating a Room object, then it has a TODO comment, and then it returns the Room object at the end:

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

  // TODO: Finish setting up my_room

  return my_room;
}

Note that this function has access to a float width and a float length variable, which you will be using when you write your code.

At the TODO line, work with the my_room variable to set its member variables.

Member variable Assign to…
my_room.width width
my_room.length length
my_room.area width * length
my_room.perimeter 2 * width + 2 * length

Afterwards you can run the program to manually check your work and you can run the AUTOMATED TESTS to verify that all the tests pass.


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

      gitlab_web_editfile2.png

    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.

      gitlab_web_editfile5b.png

    6. On Canvas, locate the assignment. Click "Start assignment".
    7. Paste the copied URL into the box and click "Submit assignment".

      canvas-submit.png

πŸ‹οΈ Unit 05 Debugging - Debugging review - C++ basics (U05.EXE.D)

πŸ‹οΈ Nonogram - Nonogram D (U05.EXE.N)

How to play: Each cell in the grid of squares can either have a X (or blank) or be filled in. The filled in boxes create the pixels of an image. Each row and each column have one or more numbers. This specifies how many pixels are in that row/column. The number given is how many unbroken pixels will show up together. Two numbers separated by a space, e.g., "1 1", will have at least one empty spot between them.

nonogram-07.png

Hint: Tree

nonogram-08.png

Hint: Chocolate chip cookie

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

πŸ§‘β€πŸ« Unit 05 Status Update - Structs (U05.SUP.202401CS200)

WEEK 6 - FEB 26

UNIT 06: Functions

πŸ“–οΈ Reading - Functions (U06.READ)

reading_u06_Functions_image.png

  • Program Structure

    errorinmain.png

    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.

    reading_u06_Functions_functioncall.png

    reading_u06_Functions_programbreakout.png


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

      nocomp.png


      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.

      badcode.png


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

      copyparameter.png


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

πŸ§‘β€πŸ”¬ Lab - Function (U06.LAB)

What we're gonna do:

  • Practice writing functions with a void return type and no parameters
  • Practice writing functions with a void return type but with parameters
  • Practice writing functions that return data but have no parameters
  • Practice writing functions that return data and with parameters
  • To build your code in the terminal:
    • If the program has .h and .cpp files: g++ *.h *.cpp
    • If the program only has .cpp files: g++ *.cpp
  • To run the program:
    • Windows: .\a.exe
    • Linux/Mac: ./a.out

practice1_NoInNoOut

1. Add item
2. Checkout

For this mini-program we're practicing writing a function that doesn't take any input parameters and doesn't return any output data. This function will just display a menu to the screen and nothing else. (We will use this later in the graded program.)

Note that the file is laid out like this:

// -- FUNCTION DEFINITION GOES HERE -------------------------------------------


int main()
{
  // -- IMPLEMENT PROGRAM HERE --------------------------------------------------


  return 0;
}

Your function definition will go BELOW the comment "FUNCTION DEFINITION GOES HERE", OUTSIDE of the main() function.

Implement the function:

Under "FUNCTION DEFINITION GOES HERE", create a function definition:

  • Return type: void
  • Parameters: none
  • Function name: DisplayMenu

Within the function body, use cout statements to display two options: 1. Add item, or 2. Checkout.

When you run the program, it will display the menu - this program will not do anything else, but we will reuse this function in the graded program.

QUESTION: How do I create this function?

The function header will be: void DisplayMenu(), then add a code block { } in the lines after it.


Call the function:

Within main, call the DisplayMenu function.

QUESTION: How do I call this function?

Call the function by using its name and parentheses with a semicolon at the end: DisplayMenu();, since this function doesn't take any parameters, nothing else is needed here.


practice2_YesInNoOut

Enter an amount of money: 5.3
$5.30

Implement the function:

Under "FUNCTION DEFINITION GOES HERE", create a function definition:

  • Return type: void
  • Parameters: price, a float
  • Function name: FormatUSD

Within the function body use cout statements to display the price variable with USD formatting.

QUESTION: How do I create this function?

The function header will be: void FormatUSD( float price ), then add a code block { } in the lines after it.

QUESTION: How do I set up USD formatting again?

Use cout << fixed << setprecision( 2 ); to set up the basic style. You'll also want to manually output a "$" dollar sign before the variable you want to display.


Call the function:

Within main(), create a float variable named input. Display a message to the user, "Enter an amount of money:", then get their input and store it in the input variable.

Next, call the FormatUSD function, passing in the input as the argument.

QUESTION: How do I call this function?

To call the function we need the function name and data for its parameters. FormatUSD takes in one float, so it will look like:

FormatUSD( input );


practice3_NoInYesOut

Tax rate is: 9.61

Implement the function:

Under "FUNCTION DEFINITION GOES HERE", create a function definition:

  • Return type: float
  • Parameters: none
  • Function name: GetTaxPercent()

    Within the function body, use the return keyword and return the hard-coded value 9.61.

QUESTION: How do I create this function?

The function header will be: float DisplayMenu(), then add a code block { } in the lines after it.


Call the function:

Within main(), declare a float variable, like tax.

Call the GetTaxPercent function, assigning its return value to the tax variable.

Finally, display "Tax rate is:", and then the tax variable to the screen.

QUESTION: How do I call this function?

This function returns data, so we need to store its returned data in a variable. That will look like this:

tax = GetTaxPercent();


practice4_YesInYesOut

Enter price: $3.5
Enter tax: %9.58
Updated price: $3.8353

Implement the function:

Under "FUNCTION DEFINITION GOES HERE", create a function definition:

  • Return type: float
  • Parameters: original_price, a float, and tax_percent, a float.
  • Function name: GetPricePlusTax

Within the function body, return the new price. You can calculate it as: original_price + ( tax_percent/100 * original_price )

QUESTION: How do I create this function?

The function header will be: float DisplayMenu( float original_price, float tax_percent ), then add a code block { } in the lines after it.


Call the function:

Within main(), create three float variables: price, tax, and updated_price.

Display "Enter price:" to the screen and get the user's input, store it in the price variable.

Display "Enter tax:" to the screen and get the user's input, store it in the tax variable.

Call the GetPricePlusTax function, passing in price and tax as the input arguments. Store the returned data in the updated_price variable.

Finally, display "Updated price:" and the updated_price to the screen.

QUESTION: How do I call this function?

This function takes in data and it returns data, so we need items in the parameter list and we need to store its return data in a variable:

updated_price = GetPricePlusTax( price, tax );


Graded program: Purchase Calculator

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

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():

  1. A few variables are already declared: final_price, transaction_total, running, new_price, and choice.
  2. WHILE running is true, do:
    1. Display "Current transaction amount:"
    2. Call the FormatUSD function, passing in the transaction_total. (DON'T use a cout on this line!)
    3. Call the DisplayMenu function.
    4. Call the GetChoice function passing in 1 and 2 as the arguments. Store the return data in the choice variable.
    5. 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.
    6. Otherwise if choice is 2:
      1. Set running to false so that the loop will end and the program will continue.
  3. After the while loop is over, display the text "RECEIPT".
  4. Call the GetPricePlusTax function, passing in transaction_total and GetTaxPercent() as its arguments. Store its return data in the final_price funnction.
  5. Display "Transaction total:".
  6. Call FormatUSD, passing in the transaction_total. (DO NOT USE cout HERE.)
  7. Display "Tax rate:", then call GetTaxPercent(), all in one cout statement.
  8. Display "After tax:".
  9. Call the FormatUSD function, passing in the final_price. (Do not use cout here.)
  10. 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.

🧠 Tech Literacy - Software development lifecycle (U06.TEC)

πŸ§‘β€πŸ« Status Update - Functions (U06.SUP.202401CS200)

WEEK 7 - MAR 4

Project 2

WEEK 8 - MAR 11 - SPRING BREAK

WEEK 9 - MAR 18

UNIT 07: Strings

πŸ§‘β€πŸ”¬ Lab - Strings (U07.LAB)

What we're gonna do:

  • Look at the cplusplus.com documentation for strings
  • Work with some common string operations
  • To build your code in the terminal:
    • If the program has .h and .cpp files: g++ *.h *.cpp
    • If the program only has .cpp files: g++ *.cpp
  • To run the program:
    • Windows: .\a.exe
    • Linux/Mac: ./a.out

  • Graded program:

    Graded program: String operations program

    - STRING PROGRAM ---------------------------------------------------------------
    OPTIONS:
    
    0. RUN AUTOMATED TESTS
    
    1. String length
    2. Get letter
    3. Find substring
    4. Combine strings
    5. Compare strings
    6. String relations
    7. Insert string
    8. Erase string
    9. Replace string
    
    >> 1
    Enter a string: hello there!
    The length of your string is: 12 characters
    
    --------------------------------------------------------------------------------
    

    When we run this program there will be the option to run the automated tests (0) or do various string operations. Each of these correspond to a function that we'll implement within the Functions.cpp file.


    • unsigned int GetStringLength( string text )
      Enter a string: everything changed when the Fire Nation attacked
      The length of your string is: 48 characters
      

      Docs: https://cplusplus.com/reference/string/string/size/

      Use the string's size function to return the size of the text string.


    • char GetLetter( string text, unsigned int position )
      Enter a string: the quick brown fox jumps over the lazy dog
      Enter a position #: 10
      The letter at position 10 is: b
      

      Docs: https://cplusplus.com/reference/string/string/size/

      Use the string's subscript operator to return a letter in text at the position specified.


    • int GetSubstringPosition( string haystack, string needle )
      Enter the full string: never gonna let you up
      Enter the substring to search for: gonna
      The substring was found at position 6
      

      Docs: https://cplusplus.com/reference/string/string/find/

      Use the string's find function to see if needle is in the haystack; return the position.


    • string CombineStrings( string str1, string str2 )
      Enter a first string: we can dance...
      Enter a second string: if we want to
      The strings combined is: "we can dance...if we want to"
      

      Docs: https://cplusplus.com/reference/string/string/operator+/

      Use the string's concatenation operator to combine str1 and str2 and return the result.


    • int CompareStrings( string str1, string str2 )
      Enter a first string: cat
      Enter a second string: dog
      The comparison between string 1 and string 2 is: -1
      

      Docs: https://cplusplus.com/reference/string/string/compare/

      Use the string's compare function to compare str1 and str2 and return the result.


    • string StringRelations( string str1, string str2 )
      Enter a first string: cat
      Enter a second string: dog
      The relation between string 1 and string 2 is: cat < dog
      

      Docs: https://cplusplus.com/reference/string/string/operators/

      Use the relational operators < and > to return "[str1] < [str2]" or "[str1] > [str2]" or "[str1] == [str2]".


    • string InsertString( string original, string insert_me, int position )
      Enter first string: banphone
      Enter string to insert: ana
      Enter position where to insert it: 3
      The string is now: "bananaphone"
      

      Docs: https://cplusplus.com/reference/string/string/insert/

      Use the string's insert function to insert the insert_me string into the original string at the position given. Return the result.


    • string EraseFromString( string original, int position, int length )
      Enter string: I can't even comprehend
      Enter position to begin erasing from: 12
      Enter length of characters to remove: 11
      The string is now: "I can't even"
      

      Docs: https://cplusplus.com/reference/string/string/insert/

      Use the string's erase function to remove text from the original string, starting at the position given, and going for length amount of characters. Return the result.


    • string ReplaceInString( string original, string insert_me, int position, int length )
      Enter a first string: good work
      Enter a second string: bad
      Enter starting position of string 1 to replace: 0
      Enter length of characters to remove: 4
      The string is now: "bad work"
      

      Docs: https://cplusplus.com/reference/string/string/replace/

      Use the string's replace function to replace text in the original string at position, going for the length given, replacing the text with the insert_me string. Return the result.


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

UNIT 08: File I/O

πŸ§‘β€πŸ”¬ Lab - File I/O (U08.LAB)

What we're gonna do:

  • Read text in from text files using ifstream
  • Write text out to text files using ofstream
  • To build your code in the terminal:
    • If the program has .h and .cpp files: g++ *.h *.cpp
    • If the program only has .cpp files: g++ *.cpp
  • To run the program:
    • Windows: .\a.exe
    • Linux/Mac: ./a.out

  • practice1_savefile
    
    

  • practice2_loadsingle
    
    

  • practice3_loadline
    
    

  • practice4_readitall
    
    

  • practice5_saveload
    
    

  • Graded program 1: Calculate Raise
    
    

  • Graded program 2: Get line from file
    
    

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

WEEK 10 - MAR 25

UNIT 09: Pointers

UNIT 10: Arrays and vectors

WEEK 11 - APR 1

Project 3

WEEK 12 - APR 8

UNIT 11: Classes

UNIT 12: Inheritance

WEEK 13 - APR 15

Project 4

WEEK 14 - APR 22

UNIT 13: Searching and sorting

UNIT 14: Recursion

Additional

l1-about.png

About

About this book

book-cute-center.png

This "course book" contains the concept notes, assignment documentation, reference material, and other resources, all of which make up the author's Core C++ course. The goal is to be a one-stop location for all the resources you need for this course, and to give you something to keep for reference later on - in other classes, for review before a job interview, or just as a reference manual. I encourage you to write in this book, keep your notes in it, highlight it, and use it as your guide as you work through the course content.

About this course

about-course-center.png

This is a night class, with a 3 hour class session one night a week. Honestly, I try to design my courses so that you can succeed with the contents whether you are in class or not, so I try to make sure everything important is available to you online (or in this book-thing).

That being said, we do have weekly time scheduled and I have no fixed design for class periods themselves. Class time is whatever you want it to be. I usually treat it as "lab time", but if there's something you'd like to see during class time - let me know! You can also ask me about things like the professional world and what I've learned working as a software developer, or any other area I might have experience in.

Generally, I encourage students to utilize the class time to get the labs/homework done - you've already made time in your schedule for this class, so might as well utilize the time to get classwork done. Your course load will also go by faster if you happen to work in class, where you can ask me questions if you get stuck.

\vspace{0.2cm}

Course-related ideas: Example code for a course topic, example of building a BIG project and how to put it together, "Make a program about [topic]",

\vspace{0.2cm}

Other topics ideas: Working as a software developer, tips for taking university classes, how to use a Linux operating system, Open Source software, independent game development, ethics in software and game design, course and curriculum design, designing education for non-traditional students, volunteering, strategies for dealing with stress and anxiety.

\vspace{0.2cm}

My course design ideals

  • I am interested in training you how to be a good software developer, which includes how the language works, designing software and good interfaces, diagnosing and fixing issues and bugs, and so on. I am not interested in making sure you're a cookie-cutter "best-student", which usually just translates to "a traditional student with the opportunity to give school 150% of their attention". I've been a non-traditional student, I've had to work full time my entire adult life, I understand that many of my students are also adults with jobs, families, and other responsibilities, and I am not interested in penalizing "non-traditional" students for not being able to make perfect attendance or get everything in by the due date 100% of the time.
  • I try to build my courses in a way like a video game - start by tutorializing and easy challenges, and as you get more experience you are faced with harder challenges, but everything's designed to help you build the skills you need to tackle everything.
  • I think that education should be free and available to everybody. (But also I need to pay bills so I am fortunate that I get to work as a teacher, which I enjoy doing.)
  • All the (good) course content I create is available online for free for anyone to access. (GitLab, my webpage, YouTube). Anything that I think you need to know to be successful will be available in some form online and outside of class; I'm not going to penalize you for not making it to class.
  • I want to help you build up your problem solving skills so I may not always answer your assignment questions directly (more in a guided, "here's a hint" way), but I am always here to answer questions and help guide you to where you need to go.
  • I miss teaching from home where I could wear sweat pants all day. We should all be able to do what we do while being comfy in sweat pants or whatever.

About the author

rachel1.png

I've been in the KC Metro area since I was around 11 years old. I started programming because I was in love with video games, and I spent my free time in my teen years (badly) programming video games. :)

\vspace{0.2cm}

Education: Homeschooled, GED, Associates in Computer Science from MCCKC, Bachelors in Computer Science from UMKC, dropped out of gradschool multiple times (UMKC, MS&T, KU) cuz money/time.

\vspace{0.2cm}

Development Work: Mostly C# (web development) and C++ (software development) professionally, also with PHP, HTML, CSS, JavaScript. Independent mobile app development for Android, independent game development with Lua or C++.

\vspace{0.2cm}

Teaching Work: Tutoring math @ MCCKC (2004), creating programming tutorials on YouTube (since 2008), adjunct teacher @ UMKC (2013, various other years), adjunct teacher @ JCCC (2016-2018), full time teacher @ JCCC (2020 - current).

\vspace{0.2cm}

Free time things: Playing video games, making video games, studying human languages, gardening, arts and crafts, journaling and organization, animating, video editing, playing piano, writing music, TTRPGs, drinking coffee, making zines, volunteering.

\vspace{0.2cm}

Other names: In the work system I'm R.W., but my full name is Rachel Wil Sha Singh. Around many friends I go by "Moose". I am nonbinary and go by various names in various contexts. I relate more to computers than I do to genders.

\vspace{0.2cm}

Links 'n' stuff:

\newpage

Reference

Basic Computer Skills

  • Basic computer skills

    How to take a screenshot

    computer_skills_printscreen.jpg

    In Windows
    Press PRINTSCREEN on your keyboard, then go to an image editing application (Paint, if you have nothing else) and use EDIT > PASTE to paste the image in.
    In Mac
    CTRL+Z, COMMAND+SHIFT+3 to take a screenshot in Mac
  • Navigating the filesystem

    Identifying file extensions

    You should be aware of the extensions of our files. You will need to be able to identify source code files, such as .cpp and .h files for C++, or .py files for Python. Additionally, most executable (runnable) files end with the .exe extension in Windows.

    Turning on viewing file extensions in Windows

    computer_skills_extensions.png

    By default, Windows hides file extensions from you. However, it is important to know what kind of files you're working with in a programming class. To view file extensions, search for "File Explorer Options". Select the "View" tab, and UNCHECK the option "Hide extensions for known file types". Hit OK when done.

    Project working directory

    Visual Studio: computer_skills_workingdir_visualstudio.png

    Code::Blocks: computer_skills_workingdir_codeblocks.png

    It is important to keep in mind that the default working directory of our programs is the location where the project file is. For Visual Studio, that's a .vcxproj file. For Code::Blocks, that's a .cbp file.

    Navigating quickly

    Selecting multiple files with CTRL or SHIFT

  • Editing text

    Cut (CTRL+X), copy (CTRL+C), paste (CTRL+V)

    Double-click to highlight word

    CTRL+arrow keys to scroll a word at a time

    CTRL+HOME/CTRL+END to go to start/end of a document

    SHIFT to select regions of text

  • IDE tips and tricks

    Splitting code views

    Go to declaration

    Go to definition

    Find all references

    Refactor - Rename


Code and UI Style Guide

  • User Interface Style Guide
    • Prompts before inputs

      Before using an input statement (e.g., cin), use an output statement (e.g., cout) to display a message to the user. Make sure you're clear about what kind of data you're expecting them to enter.

      No:

      _
      

      If you use an input statement it doesn't show anything on the screen, so it looks like your program has crashed.

      Yes:

      Please enter pet name: _
      

      Use an output statement to display a message before getting the user's input.


  • C++ Style Guide
    • Naming conventions
      Variables

      lowerCamelCase - Variable names should begin with a lower-case letter and each subsequent letter use an Upper Case, in a camel-case format.

      Additionally:

      • Variable names should be descriptive.
      • Avoid using single-letter variable names except with for loops.
      Member variables
      m_lowerCamelCase - Variables that belong to a class should be prefixed with m_ to signify "member".
      Functions
      CamelCase - Function names should begin with an upper-case letter and be in CamelCase form. In some cases, using an underscore might be okay to group like-functions together, if it makes things more clear.
      Classes
      CamelCase - Class names should begin with an upper-case letter and be in CamelCase form.

    • File organization
      Function/class declarations
      Function and class declarations should go in a header (.h) file.
      Function definitions
      Function definitions should go in a source (.cpp) file, EXCEPT TEMPLATED FUNCTIONS (those all go in .h).

    • Clean code
      Whitespace
      Adequate whitespace should be used to differentiate logical sections of code. At the same time, don't use too much whitespace. The goal is to have readable code.
      If ( true ) return true; else return false;
      If you're writing a condition to check if something is true in order to return true, just return the result of the condition instead.

      No:

      if ( a == b )
        return true;
      else
        return false;
      

      Yes:

      return ( a == b );
      

    • Curly braces
      Follow the existing code base
      • If you're writing code from scratch you can follow whatever style you'd like as long as it is consistent.
      • When working with existing code-bases, use the same style as the existing code.
      • See https://en.wikipedia.org/wiki/Indentation_style for indentation styles

      Preferred style:

      if ( a == b )
      {
        DoThing();
      }
      

      GNU styling:

      if ( a == b )
        {
          DoThing();
        }
      

      K&R Styling ("JavaScript" style):

      if ( a == b ) {
        DoThing();
      }
      
      One-line contents
      Always surround your if statement and while loop contents within curly braces { } even though it's not required for one-line internals.

      No:

      if ( CONDITION )
        DoThingA();
      else if ( CONDITION2 )
        DoThingB();
      else
        DoThingC();
      

      Yes:

      if ( CONDITION )
      {
        DoThingA();
      }
      else if ( CONDITION2 )
      {
        DoThingB();
      }
      else
      {
        DoThingC();
      }
      

      Or:

      if      ( CONDITION )  { DoThingA(); }
      else if ( CONDITION2 ) { DoThingB(); }
      else                   { DoThingC(); }
      

    • Cross-platform support
      File guards
      Always use ifndef instead of pragma once for your file guards.

      Yes:

      #ifndef _MYFILE_H
      #define _MYFILE_H 
      
      // My code
      
      #endif
      

      No:

      #pragma once
      
      // My code
      

    • Best practices
      • NEVER USE GLOBAL VARIABLES.
      • NEVER USE goto STATEMENTS.


C++ Quick Reference

  • Starter C++ programs

    Without arguments:

    int main()
    {
      return 0;
    }
    

    With arguments:

    int main( int argCount, char* args[] )
    {
      return 0;
    }
    
  • Variables and named constants

    Declare a variable

    DATATYPE VARIABLENAME;

    int myNumber;
    string myString;
    float myFloat;
    

    Declare a variable and initialize it

    DATATYPE VARIABLENAME = VALUE;

    int myNumber = 10;
    string myString = "Hello!";
    float myFloat = 9.99;
    char myChar = 'a';
    bool myBool = true;
    

    Declare a named constant

    const DATATYPE NAME = VALUE;

    const int NUMBER = 10;
    const string STATE = "Missouri";
    

    Assign a value to a variable that has already been declared

    VARIABLENAME = VALUE;

    myNumber = 100;
    myString = "Goodbye";
    

    Copy a value from one variable to another

    UPDATEDVAR = COPYME;

    vipStudent = student3;
    
  • Console input and output

    Output text to the console

    cout << ITEM;

    You can mix variables and string literals, as long as the stream operator << is between each item.

    cout << "Text";
    cout << myVariable;
    cout << "Label: " << myVariable << endl;
    

    Get input from the keyboard and store it in a variable

    cin >> VARIABLENAME;

    cin >> myInteger;
    cin >> myString;
    

    Get a full line of text (with spaces) and store in a variable (string only)

    getline( cin, VARIABLENAME );

    getline( cin, myString );
    

    Note that if you have a cin >> statement immediately before the getline statement, your input will get skipped. In this case you need to add a cin.ignore() statement:

    cin >> myNumber;
    cin.ignore();
    getline( cin, myString );
    
  • Branching

    If statement

    If the condition evaluates to true, then execute the code within the if statement. Otherwise, skip that code completely.

    if ( a == 1 )
    {
    }
    

    If/else statement

    If the condition from if statement results to false, then the code in the else case is executed instead. No condition is written with the else case.

    if ( a == 1 )
    {
    }
    else
    {
    }
    

    If/else if statement

    Checks each condition in order. If one is true, then subsequent else if statements are ignored.

    if ( a == 1 )
    {
    }
    else if ( a == 2 )
    {
    }
    

    If/else if/else statement

    Similar to above, but if all if and else if statements are false, then else is executed.

    if ( a == 1 )
    {
    }
    else if ( a == 2 )
    {
    }
    else
    {
    }
    
  • Switch

    switch( VARIABLE ) { case VALUE: break; }

    switch( myNumber )
    {
      case 1:
        cout << "It's one!" << endl;
        break;
    
      case 2:
        cout << "It's two!" << endl;
        break;
    
      default:
        cout << "I don't know what it is!" << endl;
    }
    
  • Loops

    Looping with While Loops

    Runs 0 or more times, depending on whether the CONDITION is true.

    while ( CONDITION ) { }

    while ( a < b )
    {
      cout << a << endl;
      a++;
    }
    

    Looping with Do…While Loops

    Runs at least once and then continues looping if the condition is true.

    do { } while ( CONDITION );

    do {
      cout << "Enter a number: ";
      cin >> input;
     } while ( input < 0 || input > max );
    

    Looping with For Loops

    Iterate some amount of times through the loop based on your counter variable and range.

    for ( INIT; CONDITION; UPDATE ) { }

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

    Looping with Range-Based For Loops

    Iterates over all elements in a collection. Only moves forward, doesn't give access to index

    for ( INIT : RANGE ) { }

    vector<int> myVec = { 1, 2, 3, 4 };
    for ( int element : myVec )
    {
      cout << element << endl;
    }
    
  • Arrays and Vectors

    Declare a traditional C-style array

    When declaring a vanilla array, you need to set its size. You can either hard-code the size with a number:

    string arr[10];
    

    Or use a named constant:

    const int TOTAL_STUDENTS;
    string students[TOTAL_STUDENTS];
    

    Declare an STL array object Remember that you will need #include <array> at the top of your file to use the array object.

    Declare an array object, passing in what the data type of it values are, and the size of the array:

    array<float, 3> bankBalances;
    

    Use the array documentation (https://cplusplus.com/reference/array/array/) for info on its functions.

    Declare an STL vector object

    vector<string> studentList;
    

    Use the vector documentation (https://cplusplus.com/reference/vector/) for info on its functions.

    Initialize array/vector with an initializer list

    string cats1[] = { "Kabe", "Luna", "Pixel", "Korra" };
    array<string,4> cats2 = { "Kabe", "Luna", "Pixel", "Korra" };
    vector<string> cats3 = { "Kabe", "Luna", "Pixel", "Korra" };
    

    Iterate over an array/vector

    // C-style array:
    for ( int i = 0; i < TOTAL_STUDENTS; i++ )
    {
      cout << "index: " << i << ", value: " << students[i] << endl;
    }
    
    // STL Array and STL Vector:
    for ( size_t i = 0; i < bankBalances.size(); i++ )
    {
      cout << "index: " << i << ", value: " << students[i] << endl;
    }
    

    size_t is another name for an unsigned int, which allows values of 0 and above - no negatives.

  • File I/O

    Make sure to have #include <fstream> in any files using ifstream or ofstream!

    Create an output file and write

    ofstream output;
    output.open( "file.txt" );
    
    // Write to text file
    output << "Hello, world!" << endl;
    

    Create an input file and read

    ifstream input;
    input.open( "file.txt" );
    if ( input.fail() )
      {
        cout << "ERROR: could not load file.txt!" << endl;
      }
    string buffer;
    
    // read a word
    input >> buffer;
    
    // read a line
    getline( input, buffer );
    
  • Functions

    Prevent file duplication

    When creating .h/.hpp files, it is important to include these lines to prevent file duplication, which happens if you #include this file in more than one place.

    #ifndef _FILENAME_H // LABEL SHOULD BE UNIQUE FOR EACH .h FILE!
    #define _FILENAME_H
    
    // Code goes here
    
    #endif
    

    Function declaration

    A function declaration contains the function header and no body. It declares that the function exists and will be defined elseware.

    void DisplayMenu();
    int Sum(int a, int b);
    

    Function definition

    A function definition defines how the function operates. It includes the function header and a function body, which has commands in it.

    void DisplayMenu()
    {
      cout << "1. Deposit" << endl;
      cout << "2. Withdraw" << endl;
      cout << "3. Quit" << endl;
    }
    
    int Sum(int a, int b)
    {
      return a + b;
    }
    

    Calling a function

    Calling a function requires invoking the function's name and passing in any arguments.

    DisplayMenu();
    
    int result = Sum( 1, 2 ); // Passing in literal values
    
    int num1 = 2;
    int num2 = 5;
    int result = Sum( num1, num2 ); // Passing in variable values
    
  • Classes

    Declaring a class

    Remember that classes must end with ; on their closing curly brace!

    class CLASSNAME
    {
        public:
        // Public members
    
        protected:
        // Protected members
    
        private:
        // Private members
    };
    
    class Student
    {
    public:
      // Constructor functions
      Student();
      Student( string name, float gpa );
    
      // Member functions
      void Setup( string name, float gpa );
      void Display();
    
    private:
      // Member variables
      string m_name;
      float m_gpa;
    };
    

    Defining a class member function (method)

    A class' member functions must be declared within the class declaration. Then, you define the member function within a .cpp file.

    RETURNTYPE CLASSNAME::FUNCTIONNAME( PARAMETERS )

    // Function definition
    void Student::Setup( string name, float gpa )
    {
      m_name = name;
      m_gpa = gpa;
    }
    

    Getter and Setter patterns

    It is best practice to make member variables private to protect the integrity of the data. Private members cannot be accessed outside of the function, so instead you'll have to create interfacing functions to access (get) and mutate (set) data.

    Getter function, aka Accessor
    • Doesn't take in any inputs (parameters)
    • Returns the value of the member variable (return type should match the member variable)
    • Getter functions can be good for formatting data before returning it
    // Basic getter function
    float Student::GetGPA()
    {
      return m_gpa;
    }
    
    // Example of formatting before returning data
    string Person::GetFullName()
    {
      return m_lastname + ", " + m_firstname;
    }
    
    Setter function, aka Mutator
    • Takes in an input value for a new value for the member variable - parameter should have the same data type as the member variable
    • Doesn't return any data - void return type
    • Setter functions should include any needed error checking and reject invalid data
    // Basic setter function
    void Student::SetGPA( float newGpa )
    {
      m_gpa = newGpa;
    }
    
    // Example of data validity check
    void Student::SetGPA( float newGpa )
    {
      if ( newGpa < 0 || newGpa > 4 )
      {
        cout << "Error! Invalid GPA!" << endl;
        return; // Return without saving data
      }
      else
      {
        m_gpa = newGpa;
      }
    }
    
  • Pointers

    Declare a pointer

    DATATYPE* PTRNAME = nullptr;

    
    

    Assign an address to a pointer

    PTRNAME = &VARIABLE;

    int * ptrInt = nullptr;
    string * ptrString = nullptr;
    

    Pointer variables store addresses as their value. To get the address of a variable, prefix the variable name with the address-of operator &.

    int myInteger = 5;
    int * ptrInt = &myInteger;
    
    Student studentA;
    Student * ptrStudent = nullptr;
    ptrStudent = &studentA;
    

    Dereference a pointer

    cout << *ptrName; // Display contents that pointer is pointing to
    cin >> *ptrName; // Overwrite contents that pointer is pointing to
    

    Dereference an object pointer and access a member variable

    PTR->MEMBER

    Student* newStudent = new Student;
    newStudent->name = "Hikaru";
    cout << "Student name: " << newStudent->name << endl;
    

    Check if pointer is pointing to an address

    if ( ptrName != nullptr )
    {
      // Pointer is safe to use...
    }
    
  • Memory management

    Allocate memory for a single variable

    DATATYPE* PTRNAME = NEW DATATYPE;

    int * num = new int;
    Node* newNode = new Node;
    

    Deallocate memory of a single variable

    DELETE PTRNAME;

    delete num;
    delete newNode;
    

    Allocate memory for an array

    DATATYPE* PTRNAME = new DATATYPE[ SIZE ];

    int * numList = new int[100];
    Node* nodeList = new Node[10];
    

    Deallocate memory of an array

    DELETE [] PTRNAME;

    delete [] numList;
    delete [] nodeList;
    

Common C++ issues

  • Common build errors
    Undefined Reference to WinMain
    • Explanation: Your program can't find main(), the main entry-point to the program.
    • Try:
      • Make sure you've written int main() in your prgoram.
      • If working with Visual Studio, make sure you've opened a project (NOT A FILE/FOLDER!) - Is your Solution Explorer empty?
    Undefined reference to …
    • Explanation: A variable or function either has not been declared or cannot be found at the current location in the program.
    • Try: Check to make sure you don't have any typos, that your variables have been declared, that your #include are set up properly, and that any functions declared also are defined elseware.
    Use of undeclared identifier XYZ
    • Explanation: You're trying to use a variable XYZ but you have not declared it at this point in the program.
    • Try: Look for your variable declaration and make sure it shows up before any code that uses this variable.
    Unresolved external symbol ABC
    • Explanation: This usually means you've made a call to a function that doesn't exist - perhaps you've declared it somewhere, but never wrote the function's definition.
    • Try: Double checking that all your function declarations' and definitions' headers MATCH!
    Object of abstract class type is not allowed / Cannot instantiate abstract class
    • Explanation: You're trying to create an object (that is, a variable whose data type is a class), and the class you're using is still an abstract class. This could be because you haven't overridden all of its parents' pure virtual functions, or perhaps a typo between the parent class' function signature and the child class' function signature.
    • Try: Look at class' parent - for any pure virtual functions (e.g., virtual RETURN FUNC() = 0;), make sure you have declared and defined them in the child class.
    cannot convert from ABC to XYZ
    • Explanation: The program is expecting an XYZ data type in a location where you're giving it an ABC type instead.
    • Try: If you're working with a class object, perhaps you need to pass a member variable of that class object instead?
    ABC already defined in XYZ
    • Explanation: This error is saying that a function has already been defined elsewhere. There could be a few reasons.
    • Try:
      • Are you missing the #ifndef file guards in a .h file?
      • Have you defined a given function more than once?
      • Run a Clean and Rebuild in your IDE.
      • Make sure that you DO NOT HAVE #include FOR ANY .cpp FILES!!
    Operator -> applied to ABC instead of pointer type
    • Explanation: You're trying to dereference an object that is not a pointer.
    • Try: Perhaps you're storing a vector of pointers? Make sure you're accessing a single element.
    error: implicit instantiation of undefined template 'std::basicifstream
    • Explanation: Missing an include for the fstream library.
    • Try: Don't forget to put #include <fstream> in the code files where you're using ifstream or ofstream.
  • Common runtime errors
    Memory access violation
    • Explanation: If the memory address it shows you is 0x00000 or something with a lot of zeroes, then you're trying to access a pointer that is pointing to nullptr.
    • Try:
      • Check to make sure you're not going outside of bounds on an array.
      • Check to make sure you're checking if a pointer is NOT pointing to nullptr before de-referencing it.
  • Weird software issues
    Windows maximum path length error
    • Explanation: Windows has a setting that limits the maximum file path length. If your repository is deep down many folders, you may encounter this issue.
    • Fixes:
      • Enable long paths - The Windows documentation (https://docs.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation) has some information on enabling long paths.
      • OR Move your project directory - If you move your project directory to something like C:\ instead of the desktop (which is actually C:\Users\blahblahblah\Desktop) or the default visual studio project path (C:\Users\blahblahblah\source\repos) this will help avoid this maximum path length issue.
    Visual Studio: Fatal error LNK1104: cannot open file …exe
    • Explanation: Visual Studio is trying to build the program but cannot overwrite the .exe file.
    • Fixes:
      • Try to close Visual Studio and re-open it - Sometimes if your program crashed last time you ran it, Visual Studio will be unable to update the .exe file and give this error.
      • OR Turn off your virus scan - Sometimes your virus scan will see the .exe file you just built as an ``unknown threat'' and prevent it from opening, which also causes this error.
    Code::Blocks: error: ld returned 1 exit status
    • Try: Make sure you do not have any #include statements that include a .cpp file. Includes only work with .h and .hpp files, or library files in < > brackets.
    Code::Blocks: Modern C++ features not working
    • Fix: In this case you'll need to set up your compiler to build for a modern C++ version, rather than the default of C++98 (from 1998). In Code::Blocks, go to Settings > Compiler… Then, check the box that is next to the Have g+ follow the C++17 ISO C++ language standard [-std=c++17] option, or the C++14 one if that's not available.
    • codeblocks-compiler.png
    XCode: Cannot find functions
    • Explanation: This is a result of creating a new file in XCode, but choosing the wrong file type. When adding .cpp files, make sure you select a C++ file object.
    • reference-cannotfind.png
    XCode: Where are my output/input text files??
    • You will need to set up a Working Path for your projects in XCode. You can get to this option by going to the menu bar: Scheme -> Edit Scheme. You will want to set your working directory to a specific path where you can locate the text files.
    • xcode-working-directory.png
  • Git issues
    Git: There is no tracking information for the current branch.
    • Error message: There is no tracking information for the current branch. Please specify which branch you want to merge with.
    • Explanation: Git isn't sure what branch you're working with; tell it explicitly.
    • Try: git pull origin main
    • git-specifybranch.png
    Git: [rejected] error: failed to push some refs
    • Error message: ! [rejected] error: failed to push some refs hint: Updates were rejected because the tip fo your current branch is behind hint: its remote counterpart. Integrate the remote changes (e.g. hint: 'git pull …') before pushing again. hint: See the 'Note about fast-forwards' in 'git push –help' for details.
    • Explanation: There are changes on the server that you don't have on your local machine yet. A merge needs to happen.
    • Try: The hint gives you the solution: Run git pull and then repeat your git push after the merge.
    • git-pushfail.png
    Git: fatal: not a git repository (or any of the parent directories): .git
    • Error message: fatal: not a git repository (or any of the parent directories): .git
    • Explanation: You are not running your git commands from within a repository folder.
    • Try: Make sure you open Git Bash within a folder, or use the cd commands to navigate to your repository path.
    • git-notarepo.png
    Git: error: Browse.VC.opendb Permission denied
    • Error message: error: open("…./Browse.VC.opendb"): Permission denied error: unable to index file '…/Browse.VC.opendb' fatal: adding files failed
    • Explanation: This happens because Visual Studio is still open and Visual Studio dislikes its project files changing.
    • Try: Close Visual Studio before running git add.
    • permission-denied.png

Archive - Video links

Syllabus

Course information

College Johnson County Community College
Division CSIT (Computer Science/Information Technology)
Instructor Rachel Wil Singh (they/them)
Semester Spring 2024 (01/22/2024 - 05/13/2024)
Course CS 200: Concepts of Programming with C++ (4 credit hours)
Section Section 400 / CRN 10953 / HyFlex / Mondays, 6:00 - 8:00 pm
Course description
This course emphasizes problem solving using a high-level programming language and the software development process. Algorithm design and development, programming style, documentation, testing and debugging will be presented. Standard algorithms and data structures will be introduced. Data abstraction and an introduction to object-oriented programming will be studied and used to implement algorithms. 3 hrs. lecture, 2 hrs. lab by arrangement/wk. Catalog link: https://catalog.jccc.edu/coursedescriptions/cs/#CS_200
Drop deadlines
To view the deadline dates for dropping this course, please refer to the schedule on the JCCC website under Admissions>Enrollment Dates> Dropping Credit Classes. After the 100% refund date, you will be financially responsible for the tuition charges; for details, search on Student Financial Responsibility on the JCCC web page. Changing your schedule may reduce eligibility for financial aid and other third party funding. Courses not dropped will be graded. For questions about dropping courses, contact the Student Success Center at 913-469-3803.
Auto-withdraws
Attendance for the first week of classes at JCCC are recorded and students marked as NOT IN ATTENDANCE get auto-withdrawn from the course. Please pay attention to course announcements / emails from the instructor for instructions on how to make sure you are marked as IN ATTENDANCE.

Instructor information

  • Name: Rachel Wil Singh, aka R.W.
  • Pronouns: they/them
  • Office: RC 348 H
  • Email: rsingh13@jccc.edu (please use Canvas email instead)
  • Office phone: (913) 469-8500 x3671

Course delivery

This course is set up as a HyFlex course. This means the following:

  • Courses have a scheduled "in-class" time each week.
  • Students can choose to attend class in one of three ways:
    1. In person in the classroom during class time
    2. Remotely via Zoom during class time
    3. Watch the archived Zoom lecture after class time
  • A Zoom link will be available for each class session. Please see the Canvas page, under "Zoom", for the link.
  • Class sessions will be recorded and you can view them afterwards. Please see the Canvas page, under "Zoom", then "Cloud recordings".

To see more about JCCC course delivery options, please visit: https://www.jccc.edu/student-resources/course-delivery-methods.html

Office hours Office hours are weekly times that the instructor is available, either on-campus and/or via Zoom. If the pre-determined office hours don't work with your schedule, you can also schedule a one-on-one time to meet with the instructor.

Office hours are drop-in, and you can attend during any pre-scheduled times; you do not need to ask to join in. You may be placed in a waiting room if I am working with another student on something.

Scheduled office hours:

  • Wednesdays, 12:00 - 2:30 pm, and 5:30 - 8:00 pm (ZOOM ONLY)
  • I will be on campus on Mondays and Tuesdays, please email ahead to find out times I am able to meet in person if needed.

Class communication

  • Please use Canvas email, not the @jccc email, to contact the instructor! I rely upon the Canvas email system for communication with students and only students. The direct @jccc email address also receives non-student communication such as automated campus updates, department emails, commitee emails, and so on. To ensure that I see your email in a timely manner, please email me via Canvas!
  • Instructor will respond within 1 business day I do my best to respond to emails as quickly as possible, at most within 1 business day. Emails on Friday may not get a response until Monday. If I have not responded to your email within this time period it is possible I have not seen your email, please make sure to email me through Canvas and not to my @jccc email.
  • Check course Announcements! I use the Announcements board as a way to give additional course information, assignment corrections, and other things. You can set up Canvas to email these announcements to you automatically. Please don't ignore class Announcements!
  • Course supplies
    1. Textbook: Rachel's CS 200 course notes (https://moosadee.gitlab.io/courses/202401_Spring/book_corecpp.html)
    2. Zoom: Needed for remote attendance / office hours
    3. Tools: See the UNIT 00 SETUP assignments for steps on installation.
      • WINDOWS: MinGW, a code editor
      • LINUX/MAC: g++, a code editor
      • You may need a document editor, such as LibreOffice Writer, MS Word, or Google Documents.
    4. Accounts: See the UNIT 00 SETUP assignments for steps on set up.
    5. Optional: Things that might be handy
      • Dark Reader plugin (Firefox/Chrome/Safari/Edge) to turn light-mode webpages into dark-mode. (https://darkreader.org/)

    ? What about IDEs like Visual Studio or Code::Blocks ? In this course we will be learning about building C++ programs from the command line. If you already know how to use other IDEs you are free to use them as well.

  • Recommended experience

    There are certain skills that will make your time in this class easier. Please look over this list and let me know if you need additional help with any of these things.

    Computer skills - You should have a base level knowledge of using a computer, including:

    • Navigating your Operating System, including:
      • Installing software
      • Running software
      • Locating saved files on your computer
      • Writing text documents, exporting to PDF
      • Taking screenshots
      • Editing .txt and other plaintext files
    • Navigating the internet:
      • Navigating websites, using links
      • Sending emails
      • Uploading attachments

    Learning skills - Learning to program takes a lot of reading, and you will be building up your problem solving skills. You should be able to exercise the following skills:

    • Breaking down problems - Looking at a problem in small pieces and tackling them one part at a time.
    • Organizing your notes so you can use them for reference while coding.
    • Reading an entire part of an assignment before starting - these aren't step-by-step to-do lists.
    • Learning how to ask a question - Where are you stuck, what are you stuck on, what have you tried?
    • Recognizing when additional learning resources are needed and seeking them out - such as utilizing JCCC's Academic Achievement Center tutors.
    • Managing your time to give yourself enough time to tackle challenges, rather than waiting until the last minute.

    How to ask questions - When asking questions about a programming assignment via email, please include the following information so I can answer your question:

    1. Be sure to let me know WHICH ASSIGNMENT IT IS, the specific assignment name, so I can find it.
    2. Include a SCREENSHOT of what's going wrong.
    3. What have you tried so far?

Course policies

  • Grading breakdown

    Assessment types are given a certain weight in the overall class. Breakdown percentages are based off the course catalog requirements (https://catalog.jccc.edu/coursedescriptions/cs/#CS_200)

    • Labs: Weekly programming assignments to help practice new concepts (20%)
    • Exercises: A variety of additional topics to help students learn and practice (5%)
      • Debugging practice: Assignments to help students with diagnosing and debugging skills
      • Nonograms: Small puzzles to help students practice problem solving and analysis
    • Tech Literacy discussions: Discussions about tech related areas (5%)
    • Check-ins: Weekly Check-Ins to let me know how you're doing in the course and if you need anything additional (5%)
    • Quizzes: Concept Introductions help students review concepts read about in the textbook (10%)
    • Projects: Larger programming assignments that combine multiple topics (15%)
    • Exams: Mastery Checks to help the student and instructor assess how much about a topic has been learned (40%)

    Final letter grade: JCCC uses whole letter grades for final course grades: F, D, C, B, and A. The way I break down what your receive at the end of the semester is as follows:

    Total score Letter grade
    89.5% \(\leq\) grade \(\leq\) 100% A
    79.5% \(\leq\) grade < 89.5% B
    69.5% \(\leq\) grade < 79.5% C
    59.5% \(\leq\) grade < 69.5% D
    0% \(\leq\) grade < 59.5% F
  • Tentative schedule
    Week # Monday Topic A Topic B
    1 Jan 22 Unit 00: Setup Unit 01: Exploring software
    2 Jan 29 Unit 02: Command line Unit 03: C++ basics
    3 Feb 5 Unit 04: Control flow  
    4 Feb 12 Unit 05: Structs  
    5 Feb 19 Unit 06: Functions  
    6 Feb 26 Unit 07: Strings Unit 08: File I/O
    7 Mar 4 Unit 09: Pointers Unit 10: Arrays and vectors
    8 Mar 11 SPRING BREAK  
    9 Mar 18 Unit 11: Classes Unit 12: Inheritance
    10 Mar 25 Unit 13: Searching & sorting Unit 14: Recursion
    11 Apr 1 Semester project v1  
    12 Apr 8 Semester project v1  
    13 Apr 15 Semester project v2  
    14 Apr 22 Semester project v2  
  • Due dates, late assignments, re-submissions
    • Due dates are set as a guide for when you should have your assignments in by.
    • End dates/available until dates are a hard-stop for when an assignment can be turned in. Assignments cannot be turned in after this date until The Reopening.
    • The Reopening happens at the end of the semester once I have finished preparing all content for the rest of the semester. This period allows you to turn in late assignemnts that you didn't get in by the Available Until Date for a slight reduction in maximum total points.
      • Assignments that WERE NOT TURNED IN by the Available Until Date will receive a maximum points penalty.
      • Assignments that WERE TURNED IN on time will still have a 100% maximum potential grade. This is for resubmissions to fix previous issues.
    • Resubmissions to some assignments are permitted:
      • Concept Introductions are auto-graded and you can resubmit them as much as you'd like, with the highest score being saved.
      • Labs are manually graded but you can turn in fixes after receiving feedback from the instructor.
  • Attendance

    JCCC requires us to take attendance during the first week of the semester. Students are required to attend class (if there is a scheduled class session) this first week. If there are scheduling conflicts during the first week of class, please reach out to the instructor to let them know. JCCC auto-drops students marked as not in attendance during the first week of class, but students can be reinstated. See https://www.jccc.edu/admissions/enrollment/reinstatement.html for more details.

    HyFlex classes: The following three scenarios count as student attendance for my classes:

    1. Attending class in person during the class times, or
    2. Attending class remotely via Zoom during class times, or
    3. Watching the recorded Zoom class afterwards

    Online classes: Attendance is counted as completion of assignments for a given week.

  • Class format

    Class sessions are flexible and can be changed to suit student requests. By default, class sessions are usually used for:

    • Working through example code
    • An overview of the assignments for the week
    • In-class working time

    Generally, I do not lecture during class times; there are video lectures and reading assignments that students can complete independently. Class times for this course are better used for students to get hands-on experience with the new topics while having the instructor available to answer questions and make clarifications.

  • Academic honesty

    The assignments the instructor writes for this course are meant to help the student learn new topics, starting easy and increasing the challenge over time. If a student does not do their own work then they miss out on the lessons and strategy learned from going from step A to step B to step C. The instructor is always willing to help you work through assignments, so ideally the student shouldn't feel the need to turn to third party sources for help.

    Generally, for R.W. Singh's courses:

    • OK things:
      • Asking the instructor for help, hints, or clarification, on any assignment.
      • Posting to the discussion board with questions (except with tests - please email me for those). (If you're unsure if you can post a question to the discussion board, you can go ahead and post it. If there's a problem I'll remove/edit the message and just let you know.)
      • Searching online for general knowledge questions (e.g. "C++ if statements", error messages).
      • Working with a tutor through the assignments, as long as they're not doing the work for you.
      • Use your IDE (replit, visual studio, code::blocks) to test out things before answering questions.
      • Brainstorming with classmates, sharing general information ("This is how I do input validation").
    • Not OK Things:
      • Sharing your code files with other students, or asking other students for their code files.
      • Asking a tutor, peer, family member, friend, AI, etc. to do your assignments for you.
      • Searching for specific solutions to assignments online/elseware.
      • Basically, any work/research you aren't doing on your own, that means you're not learning the topics.
      • Don't give your code files to other students, even if it is "to verify my work!"
      • Don't copy solutions off other parts of the internet; assignments get modified a little bit each semester.

    If you have any further questions, please contact the instructor.

    Each instructor is different, so make sure you don't assume that what is OK with one instructor is OK with another.

  • Student success tips
    I need to achieve a certain grade for my financial aid or student visa. What do I need to plan on?
    If you need to get a certain grade, such as an A for this course, to maintain your financial aid or student visa, then you need to set your mindset for this course immediately. You should prioritize working on assignments early and getting them in ahead of time so that you have the maximum amount of time to ask questions and get help. You should not be panicking at the end of the semester because you have a grade less than what you need. From week 1, make sure you're committed to staying on top of things.
    How do I contact the instructor?
    The best way to contact the instructor is via Canvas' email system. You can also email the instructor at rsingh13@jccc.edu, however, emails are more likely to be lost in the main inbox, since that's where all the instructor's work-related email goes. You can also attend Zoom office hours to ask questions.
    What are some suggestions for approaching studying and assignments for this course?

    Each week is generally designed with this "path" in mind:

    1. Watch lecture videos, read assigned reading.
    2. Work on Concept Introduction assignment(s).
    3. Work on Exercise assignment.

    Those are the core topics for the class. The Tech Literacy assignments can be done a bit more casually, and the Topic Mastery (exams) don't have to be done right away - do the exams once you feel comfortable with the topic.

    Where do I find feedback on my work?
    Canvas should send you an email when there is feedback on your work, but you can also locate assignment feedback by going to your Grades view on Canvas, locating the assignment, and clicking on the speech balloon icon to open up comments. These will be important to look over during the semester, especially if you want to resubmit an assignment for a better grade.
    How do I find a tutor?
    JCCC's Academic Achievement Center (https://www.jccc.edu/student-resources/academic-resource-center/academic-achievement-center/) provides tutoring services for our area. Make sure to look for the expert tutor service and you can learn more about getting a tutor.
    How do I keep track of assignments and due dates so I don't forget something?
    Canvas has a CALENDAR view, but it might also be useful to utilize something like Google Calendar, which can text and email you reminders, or even keeping a paper day planner that you check every day.
  • Accommodations and life help
    How do I get accommodations? - Access Services
    https://www.jccc.edu/student-resources/access-services/ Access Services provides students with disabilities equal opportunity and access. Some of the accommodations and services include testing accommodations, note-taking assistance, sign language interpreting services, audiobooks/alternative text and assistive technology.
    What if I'm having trouble making ends meet in my personal life? - Student Basic Needs Center
    https://www.jccc.edu/student-resources/basic-needs-center/ Check website for schedule and location. The JCCC Student Assistance Fund is to help students facing a sudden and unforeseen emergency that has affected their ability to attend class or otherwise meet the academic obligations of a JCCC student. If you are experiencing food or housing insecurity, or other hardships, stop by COM 319 and visit with our helpful staff.
    Is there someone I can talk to for my degree plan? - Academic Advising
    https://www.jccc.edu/student-resources/academic-counseling/ JCCC has advisors to help you with:
    • Choose or change your major and stay on track for graduation.
    • Ensure a smooth transfer process to a 4-year institution.
    • Discover resources and tools available to help build your schedule, complete enrollment and receive help with coursework each semester.
    • Learn how to get involved in Student Senate, clubs and orgs, athletics, study abroad, service learning, honors and other leadership programs.
    • If there’s a hold on your account due to test scores, academic probation or suspension, you are required to meet with a counselor.
    Is there someone I can talk to for emotional support? - Personal Counseling
    https://www.jccc.edu/student-resources/personal-counseling/ JCCC counselors provide a safe and confidential environment to talk about personal concerns. We advocate for students and assist with personal issues and make referrals to appropriate agencies when needed.
    How do I get a tutor? - The Academic Achievement Center
    https://www.jccc.edu/student-resources/academic-resource-center/academic-achievement-center/ The AAC is open for Zoom meetings and appointments. See the website for their schedule. Meet with a Learning Specialist for help with classes and study skills, a Reading Specialist to improve understanding of your academic reading, or a tutor to help you with specific courses and college study skills. You can sign up for workshops to get off to a Smart Start in your semester or analyze your exam scores!
    How can I report ethical concerns? - Ethics Report Line
    https://www.jccc.edu/about/leadership-governance/administration/audit-advisory/ethics-line/ You can report instances of discrimination and other ethical issues to JCCC via the EthicsPoint line.
    What other student resources are there? - Student Resources Directory
    https://www.jccc.edu/student-resources/

Additional information

  • ADA compliance / disabilities

    JCCC provides a range of services to allow persons with disabilities to participate in educational programs and activities. If you are a student with a disability and if you are in need of accommodations or services, it is your responsibility to contact Access Services and make a formal request. To schedule an appointment with an Access Advisor or for additional information, you can contact Access Services at (913) 469-3521 or accessservices@jccc.edu. Access Services is located on the 2nd floor of the Student Center (SC202)

  • Attendance standards of JCCC

    Educational research demonstrates that students who regularly attend and participate in all scheduled classes are more likely to succeed in college. Punctual and regular attendance at all scheduled classes, for the duration of the course, is regarded as integral to all courses and is expected of all students. Each JCCC faculty member will include attendance guidelines in the course syllabus that are applicable to that course, and students are responsible for knowing and adhering to those guidelines. Students are expected to regularly attend classes in accordance with the attendance standards implemented by JCCC faculty.

    The student is responsible for all course content and assignments missed due to absence. Excessive absences and authorized absences are handled in accordance with the Student Attendance Operating Procedure.

  • Academic Dishonesty

    No student shall attempt, engage in, or aid and abet behavior that, in the judgment of the faculty member for a particular class, is construed as academic dishonesty. This includes, but is not limited to, cheating, plagiarism or other forms of academic dishonesty.

    Examples of academic dishonesty and cheating include, but are not limited to, unauthorized acquisition of tests or other academic materials and/or distribution of these materials, unauthorized sharing of answers during an exam, use of unauthorized notes or study materials during an exam, altering an exam and resubmitting it for re-grading, having another student take an exam for you or submit assignments in your name, participating in unauthorized collaboration on coursework to be graded, providing false data for a research paper, using electronic equipment to transmit information to a third party to seek answers, or creating/citing false or fictitious references for a term paper. Submitting the same paper for multiple classes may also be considered cheating if not authorized by the faculty member.

    Examples of plagiarism include, but are not limited to, any attempt to take credit for work that is not your own, such as using direct quotes from an author without using quotation marks or indentation in the paper, paraphrasing work that is not your own without giving credit to the original source of the idea, or failing to properly cite all sources in the body of your work. This includes use of complete or partial papers from internet paper mills or other sources of non-original work without attribution.

    A faculty member may further define academic dishonesty, cheating or plagiarism in the course syllabus.

  • Campus Health Guidelines for COVID-19

    Follow College COVID-19 safety guidelines: https://www.jccc.edu/media-resources/covid-19/

    • Stay home when you're sick
    • Wash hands frequently
    • Cover your mouth when coughing or sneezing
    • Clean surfaces
    • Facial coverings are available and welcomed but not required
    • Wear yoru name badge or carry your JCCC photo id while on campus
  • College emergency response plan
  • Student code of conduct policy
  • Student handbook
  • Campus safety

    Information regarding student safety can be found at http://www.jccc.edu/student-resources/police-safety/. Classroom and campus safety are of paramount importance at Johnson County Community College and are the shared responsibility of the entire campus population. Please review the following:

    • Report emergencies: to Campus Police (available 24 hours a day)
      • In person at the Midwest Trust Center (MTC 115)
      • Call 913-469-2500 (direct line) – Tip: program in your cell phone
      • Phone app - download JCCC Guardian (the free campus safety app: www.jccc.edu/guardian) - instant panic button and texting capability to Campus Police
      • Anonymous reports to KOPS-Watch - https://secure.ethicspoint.com/domain/en/report_company.asp?clientid=25868 or 888-258-3230
    • Be Alert:
      • You are an extra set of eyes and ears to help maintain campus safety
      • Trust your instincts
      • Report suspicious or unusual behavior/circumstances to Campus Police (see above)
    • Be Prepared:
    • During an emergency: Notifications/Alerts (emergencies and inclement weather) are sent to all employees and students using email and text messaging
    • Weapons policy: Effective July 1, 2017, concealed carry handguns are permitted in JCCC buildings subject to the restrictions set forth in the Weapons Policy. Handgun safety training is encouraged of all who choose to conceal carry. Suspected violations should be reported to JCCC Police Department 913-469-2500 or if an emergency, you can also call 911.

Course catalog info

Objectives:

  1. Describe computer systems and examine ethics.
  2. Solve problems using a disciplined approach to software development.
  3. Utilize fundamental programming language features.
  4. Implement procedures.
  5. Employ fundamental data structures and algorithms.
  6. Write code using object-oriented techniques.
  7. Write code according to commonly accepted programming standards.
  8. Utilize a professional software development environment.

Content Outline and Competencies:

I. Computer Systems and Ethics

A. Describe basic software components.

  1. Describe operating systems.
  2. Describe high-level and machine languages.
  3. Describe compilers.

B. Examine ethics.

  1. Examine ethics in the context of software development.
  2. Examine the impact of ethics violations on software developers.
  3. Examine the impact of ethics violations on software users.

II. Problem-Solving in Software Development

A. Define the problem.

B. Develop a solution.

  1. Utilize top-down design.
  2. Consider previous problems and solutions.
  3. Reuse pertinent algorithms.
  4. Represent algorithms with pseudo-code.
  5. Identify input, output, processing and modules.

C. Code the solution.

D. Test the solution.

  1. Perform unit and integration testing.
  2. Select appropriate test data.
  3. Trace code by hand (desk-checking) and with a debugger.
  4. Evaluate code efficiency and simplicity.

III. Fundamental Programming Features

A. Declare and initialize variables and constants.

B. Use built-in operators to create expressions and statements.

  1. Write assignment statements.
  2. Create expressions with arithmetic, relational and logical operators.
  3. Use the conditional (ternary) operator.
  4. Evaluate expressions using rules of operator precedence.
  5. Compare strings and numeric types.
  6. Dereference and assign values to pointers.

C. Perform input and output.

  1. Retrieve data from the keyboard.
  2. Retrieve data from input files.
  3. Write data to the console window.
  4. Write data to output files.

D. Call built-in mathematical functions.

E. Implement type-casting.

F. Control program flow.

  1. Implement selection statements.

a. Write code with if, else and else-if statements.

b. Use switch statements.

c. Write nested selection statements.

  1. Implement repetition statements

a. Write while, for and do loops.

b. Create nested loops.

c. Analyze break and continue semantics.

G. Trap errors using selection or repetition.

IV. Procedures

A. Define and call functions with void and non-void return values.

B. Declare functions (prototyping).

C. Implement pass-by-value and pass-by-reference parameters.

D. Differentiate between actual and formal parameters.

E. Analyze and write elementary recursive code.

F. Analyze variable scope and lifetime.

G. Implement static variables.

V. Fundamental Data Structures and Algorithms

A. Implement single dimensional arrays.

  1. Implement an array of integers.
  2. Implement null-terminated strings.

B. Implement two-dimensional arrays.

C. Implement dynamic arrays.

  1. Use new and delete to manage memory.
  2. Declare pointers.

D. Search arrays.

  1. Implement sequential search.
  2. Implement binary search.

E. Sort arrays.

  1. Sort data using bubble sort.
  2. Sort data using selection sort.
  3. Sort data using insertion sort.

F. Implement structures.

G. Implement an array of structures.

VI. Object-oriented Programming

A. Write code using the built-in string class and associated methods.

B. Write code using the built-in vector class and associated methods.

C. Implement encapsulation and data abstraction by writing user-defined classes.

D. Differentiate between private and public access modifiers.

E. Hide member data.

F. Write accessors, mutators and other member functions that process member data.

G. Write code that utilizes objects.

H. Implement an array of objects.

VII. Code Standards

A. Create descriptive identifiers according to language naming conventions.

B. Write structured and readable code.

C. Create documentation.

VIII. Professional Development Environment

A. Write code using a professional, integrated development environment (IDE).

B. Utilize key editor features.

C. Debug code using the integrated debugger.

D. Include and use standard libraries.

Author: Rachel Wil Sha Singh

Created: 2024-02-21 Wed 20:27

Validate