E. Ologunde Case file
← Resource Hub Teaching

C++ Fundamentals — Course Slides

A twenty-one-module intro-to-C++ lecture deck for community college students, grounded in a full CS1/CS2 syllabus (Malik's C++ Programming plus Cisco NetAcad's C++ Essentials 1) and simplified for a first-semester audience. Every module builds toward one growing capstone program — a Student Grade & Course Tracker — so students see each new concept, from your first cout to pointers, templates, exceptions, recursion, linked lists, and casting, land in real, working code.

In plain English: a free, curated list of resources for people starting or growing a career in cybersecurity.

01

How the Course Is Structured

Each module is a self-contained, lecture-ready slide deck (12–14 slides) covering new syntax and concepts, then a Project Build slide that extends the same capstone program, and an in-class exercise to practice before moving on. Modules 1–8 cover a standard CS1 arc (syntax, control flow, functions, collections, and OOP); Modules 9–14 add CS2-level topics — pointers, templates, exception handling, recursion, linked lists, and stacks/queues — that are often skipped in a first course but show up constantly afterward; Modules 15–20 round out the language itself with topics intro courses tend to gloss over — type casting, bitwise operators, namespaces, real string manipulation, character/ASCII mechanics, operator precedence, and pointer arithmetic. By Module 21, students have a complete, sorted, file-backed C++ application built entirely from scratch.

02

Download the Modules

Module 1 Start Here
Welcome to C++
The compile pipeline, dev environment setup, program anatomy, and your first Hello World program.
Module 2
Variables, Data Types & Operators
Primitive types, constants, arithmetic/relational/logical operators, formatted decimal output, and reading input with cin.
Module 3
Control Flow: Decisions & Loops
if/else, switch, for/while/do-while loops, and validating input in a loop.
Module 4
Functions: Organizing Your Code
Pass by value vs. reference, overloading, inline functions, scope, and refactoring the project into clean functions.
Module 5
Arrays, Vectors & Strings
std::vector, std::string, and scaling from one student to a full class roster.
Module 6
Structs & Introduction to Classes
Encapsulation basics and building the first real Student class.
Module 7
OOP Deep Dive: Encapsulation & Operator Overloading
Getters/setters, const-correctness, static members, and a new Course class.
Module 8
Inheritance & Polymorphism
A GradedActivity base class with Quiz/Exam/Homework, virtual functions, pure virtual/abstract classes, and polymorphic dispatch.
Module 9
Pointers & Dynamic Memory
Memory addresses, & and *, new/delete, dynamic arrays, and the classic pointer bugs to avoid.
Module 10
Templates: Writing Generic Code
Function templates, class templates, and how std::vector<T> itself is built on the same idea.
Module 11
Exception Handling
try/throw/catch, standard exception types, and validating grade input instead of crashing on it.
Module 12
Recursion: Functions That Call Themselves
Base cases, the call stack, factorial and range-sum examples, and recursion vs. iteration.
Module 13
Linked Lists
Node structs, hand-linking pointers, traversal, and when a linked list beats a vector.
Module 14
Stacks & Queues
LIFO vs. FIFO, std::stack and std::queue, and picking the right container for the job.
Module 15
Type Conversions & Casting
Implicit vs. explicit conversion, static_cast, the classic integer-division bug, and the floating-point equality trap.
Module 16
Bitwise Operators & Boolean Logic
&, |, ^, <<, >> on individual bits, packing flags into an int, and not confusing & with &&.
Module 17
Namespaces
What "using namespace std;" has actually been doing since Module 1, and how to organize larger programs.
Module 18
String Manipulation: Search, Modify & Compare
substr, find, insert, erase, replace, and comparing strings — real text-processing beyond the basics.
Module 19
Characters, ASCII & Operator Precedence
char as a small integer, ASCII codes, escape sequences, and a full operator-precedence/associativity ladder.
Module 20
Pointer Arithmetic, Arrays & sizeof
Why ptr + 1 scales by sizeof(T), arr[i] as *(arr + i), the array-length idiom, and raw 2D arrays.
Module 21 Capstone
Searching, Sorting, File I/O & Final Assembly
Linear and binary search, sorting the roster with the STL, saving/loading to a file, and the final project rubric.

Free to use in the classroom — .pptx, opens in PowerPoint, Google Slides, or Keynote