CS162 - Winter 2026 | Chemeketa CS

Resource Links

Mon, 01 Jan 0001 00:00:00 +0000

Class Resources

Practice Quiz Questions. This link: https://liveexample-ppe.pearsoncmg.com/selftest/selftestcpp5e?username=liangcpp5e&chapter=1 takes you to Chapter 1 practice. To get to other chapters, change the chapter number in the URL (e.g. to get to Chapter 12, change the part that says "&chapter=1" to say "&chapter=12").

CPP Lab

CS162 Github repository
Github Tutorial

VSCode Setup Instructions VSCode Project Templates

Command Line Quick Reference

Valgrind Guide

CS Student Server Guide

C++

C++ Crash Course for AP CS students

LearnCpp.com online text
CPlusPlus.com reference
Fredosaurus C++ notes

C++ Guidelines from C++ bigwigs
Google's C++ Styleguide

CPP FAQ

C++ Code Visualizer

Programming Practice

Places and ways to practice programming

Week 1 - Class Overview and Structs

Mon, 01 Jan 0001 00:00:00 +0000

Learning objectives

Use structs to represent heterogeneous collections of data
Combine structs and vectors to represent collections of complex data
Use enumerations to represent related constants

Recommended Schedule

You have a lot of freedom to choose when you get the work done each week.

There is a recommended schedule below to help you break up the work into manageable chunks. Trying to do all of your learning in one monster day of studying tends to be much less effective than working on smaller chunks of the material more often.

Although the major assignments are always due at the start of next week, there are often mid-week deadlines for other work (check Canvas for all due dates), so you can't wait until the weekend to get everything done.

If your schedule requires you to do most of your work for this class on the weekend, you should try to work ahead on the next week each weekend rather than playing catchup from the previous week. That way you have plenty of time to ask questions and get any needed help before your assignments are due.

Day 2

GenAI and You
Start Ch 15 on Structs (15.1-15.6)
Start Structs exercise set (you won't be ready for the problems involving vectors yet)

Day 3

Continue Ch 15 - Enums and structs and vectors (15.7-15.10)
Do Enums exercise set
Finish Structs exercise set

You often will not need to do all the exercises listed on the Exercise page in the book. Focus on the ones shown on the assignment page in Runestone.

Day 4

Finish reading Ch 15
See Structs and Headers below
Work on Week 1 assignment

Course Intro

If you have not already watched the course intro video, do so now:

In Canvas, review the syllabus and take the class policies quiz. You can take it as many times as you like before the deadline. So make sure to get 100% on it!

The quiz is your "proof of attendance". It must be completed by Wednesday of the first week of the term or you may be dropped from the course for non-attendance.

Access Book

Watch this video to see how to use the book and complete the book based assignments.

Important Video

Videos with the notice "Important Video" contain information that is NOT covered in the book. You should make sure to watch these videos.

Videos that do not have that notice are optional supplements to the book material.

Not all assignments will be completed in the book. Canvas (Elearn) should be your primary source for assignments and due dates.

Setup

You need to have a working development environment for this course. One option is to use Github Codespaces. The other is to set up a local development environment on your computer.

Eventually, you are going to need to have a local environment, but if you have not done either in the past, using Codespaces is often easier to get started with quickly. Codespaces also has the advantage of being the same environment that I will be using for demos - there will be times when differences in local setups (OS, installed tools, etc...) can cause confusion. So even if you normally use a local setup, you will want to know how to switch to a codespace if needed to accomplish something.

So do the following:

If you have not used Codespaces before, follow the Codespaces guide for instructions on how to set up and use a Codespace.

Setup/update a local development environment, follow the Local Development Setup instructions to set up your computer. Make sure to update the templates you are using!

There will be a mini-assignment soon that requires you to show a screenshot of your local development environment working. So even if you prefer to work in a Codespace, get your local environment set up now. If you run into issues, please get help on Discord, the discussion board, or during office hours.

The templates and instructions for local development have changed recently. Even if you have done the setup before, confirm that you have the latest instructions and templates.

I recommend setting up a Codespace or making a local project that you use for testing. Any time you just want to test out a code sample or do an experiment, use that Codespace or local project.

When you are working on an assignment you will submit, create a new repository for that assignment.

GenAI and You

Generative AI is a powerful tool for programmers. It can also be a helpful tool for learning computer science. However, in both contexts, there are downsides and risks to be aware of.

There are many ethical and practical considerations in regard to Generative AI. Was the training data obtained ethically? Are there biases in the training data? Is the output correct? Is it secure? Who benefits from automating labor that a human might otherwise do?

But from a very immediate perspective, you should be concerned about what your goals are in a CS course and how using Generative AI might hinder your ability to meet those goals.

This video discusses some of these issues and provides guidance on how to use (and not use) Generative AI effectively as part of your learning process.

Important Video

Structs

Read Chapter 15.1-15.6 on Structs in the textbook.

This optional video covers key ideas:

Enums

Chapter 15.7 and 15.8 covers enumerations (enums).

This optional video covers the key ideas:

Structs and Vectors

Chapter 15.9 and 15.10 covers using structs and vectors together.

Watch this video that demonstrates how to use the debugger to inspect complex composite data types using both structs and vectors:

This optional video reviews key ideas about combining structs and vectors:

An idea that is covered by the book but is worth emphasizing is the difference between a copy of a struct and a reference to a struct. Watch this video for a deeper explanation of that concept:

Important Video

Structs and Headers

Watch this video about using structs across multiple files:

Important Video

If you need a deeper refresher on how .h files work, watch the video below and then review the Using .h/.cpp files walkthrough from CS161. Full coverage of .h/.cpp files can be found in Chapter 6.

Do Assignment 1

Start working on the first submitted assignment. It is listed as "Assignment 1" in Canvas.

Most weeks will include an assignment you will complete outside of the book and submit in Canvas. As part of starting the first assignment, you should make sure to read this document about the work history you must submit as part of every assignment.

There is a video in that document that shows how your work history is documented and how to inspect that history.

When you are complete, here is how to submit your assignment:

Important Video

Unit Testing Review

If you did not take CS161 here, you will want to watch these two videos about unit testing:

Week 2 - Introduction to Object-Oriented Programming (OOP)

Mon, 01 Jan 0001 00:00:00 +0000

Learning objectives

Design classes to represent data types in C++
Construct and read UML class diagrams
Write basic object-oriented programs using common design principles

Schedule

Day 1

Start on Object Oriented Programming - Ch 16.1-16.6

Day 2

Continue Object Oriented Programming - Ch 16.7-16.11
Work on Ch 16 Exercises

Day 3

Finish Object Oriented Programming - Rest of Ch 16. However, you can skim 16.13 and skip 16.17 entirely if you want to. You should be aware of what classes look like when implemented in modules, but your assignments will all use .h/.cpp file implementations.
Start the assignment

Day 4

Do the Local Build and Run Assignment
If you did not take CS161 here, also see the Review section.

Object Oriented Programming

Chapter 16 covers the basics of Object Oriented Programming (OOP).

The book covers implementing classes in a single module file (16.13) and in a .h/.cpp file pair (16.12). You can just skip 16.13 and focus on 16.12, since that is how you will be implementing classes in your assignments. (If you are not familiar with the difference, see Chapter 6 of the book.)

After you are through section 16.5 watch this video on using the debugger to inspect objects:

Important Video

When you get to Ch 16.12, watch this video that shows what a class split into .h/.cpp files looks like in VSCode:

Important Video

These other optional videos review key concepts from the chapter:

Big picture overview of OOP:

Basics of OOP (16.1-16.5):

(16.1-16.5)

Constructors (16.7):

Separation of Interface and Implementation (16.8):

UML (16.10):

Encapsulation (16.11):

Local Build and Run

Although GitHub Codespaces is a great environment for development, you should also be able to build and run your C++ programs on your local machine.

This week you have a mini assignment to demonstrate that you can build and run a simple C++ program locally on your machine. It requires taking a screenshot of your desktop, with VSCode (running locally, not in a Codespace) open with a C++ project loaded, and a terminal window showing the program being built and run. This video shows you how to do that:

Important Video

Review

If you did not take CS161 here, read Chapter 5.11 on Doxygen style comments. Then watch this video to learn how to easily write doxygen comments in VS Code:

Important Video

You should also review how to use the Combo Project Project Template:

Important Video

And, if you don't know how to use the debugger in VSCode to step into and out of function calls, check out this video:

Important Video

Week 3 - Pointers & Objects, Aggregation

Mon, 01 Jan 0001 00:00:00 +0000

Learning objectives

Upon finishing this week, you should be able to:

Use objects as input and output for functions
Recognize how and when to appropriately use const and static class members
Use composition to build objects from other objects
Write unit tests for classes

Suggested pacing

Day 1

Holiday - relax or work ahead

Day 2

Start on Interacting Objects - Ch 17.1-17.4
Start Ch 17 Exercises - OO Thinking

Day 3

Continue Interacting Objects - Ch 17.5-17.9
Start Ch 17 Exercises - Composition

Day 4

Continue Interacting Objects - Finish
Start the assignment. See Assignment section for a video that shows what the file structure and Makefile should look like.

Interacting Objects

Chapter 17 covers writing code involving multiple interacting objects. This includes passing objects to functions, returning objects from functions, and using objects as member variables of other objects (composition).

After you are through section 17.3 watch this video on using the debugger to track passed objects:

Important Video

Assignment

This video walks through what the setup for this week's assignment looks like:

Week 4 - Pointers & Objects, Aggregation

Mon, 01 Jan 0001 00:00:00 +0000

Learning objectives

Upon finishing this week, you should be able to:

Write and trace code that uses pointers
Use aggregation to build objects from other objects

Suggested pacing

Day 1

Pointers (Ch18.1-18.5)

Day 2

Finish Pointers (Ch18.6-18.7)
Do Pointer Exercises worksheet after 18.6 or 18.7 (See Week 4 Module)
Pointers & Objects (Ch18.8-18.9)

Day 3

Aggregation (Ch18.10-18.14)
Ch 18 Exercises

Day 4

Work on assignment
Start reading Inheritance (Ch19.1-19.4) we will be covering the rest of the chapter next week, but you should get a start on it now.

The midterm is coming up. Check the discussion board for details.

Activity Outline

Pointers

The first part of Chapter 18 covers the concept of pointers and then moves on to using pointers with objects.

This video recaps 18.1-18.5:

This next one demonstrates using the debugger in VS Code to examine pointer variables and the memory they point to. Watch it after you are done with 18.6.

Important Video

Also at that point, take a few minutes to do the Pointer Exercises worksheet available in the Week 4 Module in Canvas. In the same location, you can find an example problem that is worked step by step as well as a key to check your work. You do not need to turn this in; it is just for practice.

Pointers and Objects

Ch 18.8-18.9 focus on using pointers with objects. This videos review those sections:

18.8:

18.9:

Aggregation

The last part of Chapter 18 covers aggregation, which is using objects as member variables of other objects.

These videos review sections on aggregation:

18.10-18.11:

18.12:

Finally, this video walks through the Ch 18.13 family tree example. It demonstrates using the VSCode debugger to examine the objects and pointers involved. So even if you understand the concepts without the video, it is worth a quick watch to see the debugging techniques.

Important Video

Inheritance Basics

We will finish up Chapter 19 next week, but you should get a start on it now. The schedule for next week will assume you have read 19.1-19.4 this week.

This optional video review the basics of inheritance from those sections:

Week 5 - Inheritance, Operators

Mon, 01 Jan 0001 00:00:00 +0000

Learning objectives

Upon finishing this week, you should be able to:

Use inheritance to extend classes
Identify appropriate uses for abstract classes
Describe how virtual functions differ from regular ones and enable polymorphism
Create classes that work using standard operators

Suggested pacing

Day 1

Continue Inheritance (Ch19.5-19.9)
Do Virtual Call Practice

Day 2

Finish Inheritance (Ch19.10-19.14)
Do Inheritance Design Activity

Day 3

Midterm Review
Do Ch 19 Exercises

Day 4

Operator Overloading (Ch 20.1-20.8)

Activity Outline

Inheritance

You should have read 19.1-19.4 last week. This week we will finish up Chapter 19.

These optional videos may help:

Overriding functions (Ch 19.5):

Virtual Functions (Ch 19.7):

Object Slicing (Ch 19.8):

Abstract Functions and Classes (Ch 19.9-19.10):

Multiple Inheritance and Interfaces (Ch 19.11):

Composition vs Inheritance (Ch 19.13):

Virtual Call Practice

Virtual functions and object slicing can be tricky concepts. See the Week 5 Module in Canvas for a worksheet that has some practice problems on these topics.

Make sure you are through 19.8 before doing this worksheet.

Inheritance Design Activity

In the Week 5 Module in Canvas you will find a design activity. Tackle it after you have read through 19.12.

Midterm Review

See the week 5 Module in Canvas for a review packet. It is not a sample test per se, but it has examples of the types of questions that might be on the midterm.

The midterm will cover up through inheritance. Like the CS161 exams, the midterm will involve some writing code by hand, but it the code writing is focused on the core ideas, not all the possible syntax details. Unlike the CS161 exams, there will be questions that don't involve writing code, such as explaining ideas or designing a class.

Operator Overloading Basics

Chapter 20 introduces operator overloading. (We are not doing the exercises, just the reading.)

This optional video gives an overview of the chapter:

Week 6 - Intro to Data Structures and Algorithms

Mon, 01 Jan 0001 00:00:00 +0000

Learning objectives

Upon finishing this week, you should be able to:

Use std containers like list, set, and map
Describe the differences between various container types
Use iterators to traverse various container types
Use standard algorithms with containers

Suggested pacing

Day 1

Midterm

Day 2

Start Containers and Algorithms Ch 21.1-21.3

Day 3

Continue Containers and Algorithms Ch 21.4-21.9
Start the Ch 21 Exercises (you are ready for the first three problems, save the other)

Day 4

Continue Containers and Algorithms Ch 21.10-21.14 Note that the reading stops at 21.14. We will not be covering 21.15-16 right now, but will revisit them later.
Do the assignment

Activity Outline

This week marks a transition in focus from core programming concepts to using those concepts to build complex data structures and algorithms.

We will continue to learn some new C++ syntax and programming ideas, but more and more of our time will be spent using the ideas we know to build useful tools.

This week we are essentially doing a quick overview of the kinds of things we will be building in the rest of this course and in CS260.

Containers and Algorithms

There are many ways to organize data in a program beyond just using a vector. C++ provides a number of built-in container types that implement common data structures (as do most other programming languages).

In addition, the C++ standard library provides a large number of algorithms that can be used to manipulate data in these containers.

Read Ch 21.1-21.14.

These optional videos may help:

std::lists (Ch 21.1):

Iterators and Traversal (Ch 21.2-3):

Sets (Ch 21.4-6):

Maps (Ch 21.7-21.9):

Algorithms (Ch 21.10-21.14):

Week 7 - Memory Management

Mon, 01 Jan 0001 00:00:00 +0000

Learning objectives

Upon finishing this week, you should be able to:

Accurately describe how a program is using the stack, heap and pointers
Use destructors and copy constructors appropriately in classes
Describe and diagram the difference between a deep and a shallow copy
Write simple container classes that manage dynamic memory

Suggested pacing

Day 1

Holiday

Day 2

Dynamic Memory (Ch22.1-22.6)
Pointer Drawing WS

Day 3

Setup/Experiment with Address Sanitizer
Arrays (Ch22.8-22.9)
Ch 22 Exercises

Day 4

Container Classes (Ch22.10-22.15)
Optional: Tools for managing memory
Optional: Rule of Five

Activity Outline

Dynamic Memory

Read Ch 22.1-22.6 on dynamic memory.

Do the HeapDrawing worksheet from the classroom files link. There is a HeapDrawingSample that shows step by step how to do the problems.

This optional video review the concepts:

Address Sanitizer

Watch this video on using Address Sanitizer:

Important Video

Do the Address Sanitizer screenshot assignment.

Windows Users - Setup WSL

If you are on Windows you should install Windows Subsystem for Linux (WSL). Address Sanitizer is not available on Windows, but it is available in WSL. So you need to use a codespace or WSL to use Address Sanitizer.

Longer term, you will increasingly find it useful to have a Linux environment available for programming. WSL is a great way to get that without needing to set up a separate machine or dual boot.

These instructions will help you get it set up and use it to build and run code:

WSL Installation and Use Guide

Arrays

Pointers and arrays are surprisingly interchangeable in C/C++.

Read 22.7-22.8.

Then do the Ch 22 Exercises.

This optional video reviews some of the concepts:

Container Classes

Read 22.10-22.15 on using classes to manage memory.

This optional video explains the core ideas:

And this one explains the copy constructor and assignment operator:

Tools for Managing Memory

Optional

Garbage Collection and Smart Pointers

You may be starting to realize that managing memory on our own is difficult and error-prone. Fortunately, it is not something that we always have to do. Many programming languages provide tools to help remove some of the burdens.

This video introduces two of these tools - garbage collection and smart pointers:

Rust

Rust is a programming language that uses ownership of memory as one of its core design principles. In Rust, the goal is to never have memory that is "shared". All memory is owned by exactly one reference. We may let the memory be borrowed temporarily by something like a function, but the original reference cannot use the memory while it is borrowed and the memory may only be borrowed by one reference at a time.

This video introduces this way of thinking about memory:

Rule of Five

Optional

In modern C++ there are two other operators related to the rule of three: the move constructor and move assignment operator. They are used to write efficient code, but are not necessary. Failing to use them does not cause the same kind of errors that forgetting to implement a destructor or custom assignment operator does. This level of efficiency is the kind of thing a professional C++ developer should care about - but for now we have better uses for your brain cells.

If you want to learn more about them check the learncpp.com coverage of move constructor and move assignment operator.

Week 8 - Templates and Array Lists

Mon, 01 Jan 0001 00:00:00 +0000

Learning objectives

Upon finishing this week, you should be able to:

Create and use generic functions using templates
Create and use generic array-based data structures
Describe how array based lists implement common operations

Suggested pacing

Day 1

Start Templates (Ch 23.1-23.5)

Day 2

Continue Templates (Ch 23.6-23.7)
Start ArrayLists (Ch 23.8-23.10)
Do Ch 23 Exercises 1

Day 3

Finish ArrayLists (Ch 23.11-23.15)
Do Ch 23 Exercises 2

Day 4

Do assignment
Regular Expressions

Activity Outline

Templates

Read Ch 23.1-23.7.

These optional videos cover the basics of templates and how to include template code in your project:

Templated functions (Ch 23.1-23.4):

Including templated code (Ch 23.5):

Templated structs and classes (Ch 23.6-23.7):

Array Lists

Read Ch 23.8-23.15.

These optional videos cover the basics and more advanced features of array lists:

Array List basics (Ch 23.8-23.10):

Array List advanced (Ch 23.11-23.14):

Regular Expressions

Regular expressions don't relate to anything else in this week. And nothing we do in the future will build on them. So on one hand they are are a non-essential detour. On the other hand, there are situations where they are an indispensable tool .

Other than a few book exercises, you won't be assessed on regular expressions. But any time you invest in learning them will likely pay off in the long run. Not only are they a useful programming tool, but they are invaluable for searching and manipulating text in editors and command line tools.

Read Ch 21.15-16

This optional video covers them:

Regex Tools and References

Week 9 - Recursion and BigO Intro

Mon, 01 Jan 0001 00:00:00 +0000

Learning objectives

Upon finishing this week, you should be able to:

Trace recursive algorithms by hand
Write recursive algorithms

Suggested pacing

Day 1

Recursion Basics (Ch 24.1-24.4)
Do Recursion Practice WS

Day 2

Recursion Design (Ch 24.5-24.8)
Start Ch 24 Exercises 1 and 2 (Remember it is better to do part of each set rather than all of one and none of the other)

Day 3

Advanced Recursion (Ch 24.9-24.12)
Continue Ch 24 Exercises 1 and 2

Day 4

BigO Basics
Check out assignment

The final is coming up. Check the discussion board for details.

Activity Outline

Recursion Basics

Read Ch 24.1-24.4

Do the Recursion Practice WS. It and a key are available in Canvas.

This optional video reviews the basics of recursion:

And this brief one explains why we need recursion:

Recursion Design

Read Ch 24.5-24.8

Work on the two exercise sets for Ch 24. The second exercise set focus on using vectors and does not depend on the first one. You will likely find it easier than some of the problems in the first set, so if you get stuck on the first set, you can switch to the second one and come back to the first one later.

This optional video covers the basics of designing of recursive algorithms:

While this one covers using extra parameters to maintain state in recursive algorithms:

Advanced Recursion

Read Ch 24.9-24.12.

This optional video covers tail recursion:

And this one covers recursive algorithms that make multiple recursive calls:

Big-O

Read Ch 25.1-25.3 and 25.5 (ignore 25.4 for now)

This video reviews the core ideas:

Week 10 - Searches and Sorts

Mon, 01 Jan 0001 00:00:00 +0000

Learning objectives

Upon finishing this week, you should be able to:

Write a binary search
Write various quadratic sort algorithms
Write MergeSort
Identify the efficiency of various search and sort algorithms

Suggested pacing

Day 1

Search (Ch 24.1-24.5)

Day 2

Quadratic Sorts (Ch 24.6-26.8)
Do Ch 26 Exercises

Day 3

Merge Sort (Ch 26.9-26.12)

Day 4

Final review
See the review guide in Canvas

If you have not already done so, schedule your final. See the discussion board for details.

Activity Outline

We only have briefly covered Big-O in this course. In CS260, we will dive into the rest of Ch 25. Until that point, don't worry about understanding all the arguments about the efficiency of various algorithms. You should know which category of efficiency each algorithm falls into and have a general idea of why, but you don't need to be able to reproduce the arguments for why that is the case.

Search

Read Ch 26.1-26.5

These videos review the two approaches and their efficiency:

Quadratic Sorts

Read Ch 24.6-26.8 about insertion sort and selection sort.

This video reviews the algorithms and their efficiencies:

Merge Sort

Read Ch 24.9-26.12.

This video covers Mergesort. Coverage of the efficiency starts at ~7:00:

Finals Week

Mon, 01 Jan 0001 00:00:00 +0000

The final is an in-person, pen-and-paper exam during the scheduled final time.

CS162 - Winter 2026 | Chemeketa CS

Resource Links

Class Resources

C++

Programming Practice

Week 1 - Class Overview and Structs

Learning objectives

Recommended Schedule

Day 1

Day 2

Day 3

Day 4

Course Intro

Access Book

Setup

GenAI and You

Structs

Enums

Structs and Vectors

Structs and Headers

Do Assignment 1

Unit Testing Review

Week 2 - Introduction to Object-Oriented Programming (OOP)

Learning objectives

Schedule

Day 1

Day 2

Day 3

Day 4

Object Oriented Programming

Local Build and Run

Review

Week 3 - Pointers & Objects, Aggregation

Learning objectives

Suggested pacing

Day 1

Day 2

Day 3

Day 4

Interacting Objects

Other Videos

Assignment

Week 4 - Pointers & Objects, Aggregation

Learning objectives

Suggested pacing

Day 1

Day 2

Day 3

Day 4

Activity Outline

Pointers

Pointers and Objects

Aggregation

Inheritance Basics

Week 5 - Inheritance, Operators

Learning objectives

Suggested pacing

Day 1

Day 2

Day 3

Day 4

Activity Outline

Inheritance

Virtual Call Practice

Inheritance Design Activity

Midterm Review

Operator Overloading Basics

Week 6 - Intro to Data Structures and Algorithms

Learning objectives

Suggested pacing

Day 1

Day 2

Day 3

Day 4

Activity Outline

Containers and Algorithms

Week 7 - Memory Management

Learning objectives

Suggested pacing

Day 1