Programming & Development
C++
Learn C++ for performance-critical systems, using modern C++ practices — memory safety, STL, and clean structure.
Prerequisites
No prior experience required — open to beginners.
Certificate
Awarded by Rescue Academy on successful completion of the program's assessments and final project.
Learn Online — Live Classes
Register, receive your schedule, and join live instructor-led C++ classes on Zoom. Assignments, instructor feedback, and a certificate on completion.
Learn In Person
Attend C++ classes in person in Juba with hands-on labs, instructor mentorship, and a certificate on completion.
What You'll Learn
- Compilation, types, control flow and functions
- std::vector, std::string and standard algorithms
- References, pointers and classes with RAII
- Inheritance, virtual functions and the Standard Template Library
- Files, exceptions, CMake builds, debugging and sanitizers
- Templates, concepts, smart pointers and move semantics
- Testing, performance measurement and concurrency
Program Objectives
- Write correct, readable modern C++ that compiles cleanly with warnings enabled
- Manage object lifetime and ownership safely with RAII and smart pointers
- Use the Standard Template Library and generic programming effectively
- Build, test, debug and profile multi-file projects with professional tools
- Deliver a fast, robust tool backed by tests and measurements
Who It's For
- Beginners who want a deep understanding of how programs use memory and hardware
- Engineering and computer science students
- Developers moving into systems, embedded, game or performance-sensitive work
Where You'll Use It
- Systems software and tools that must run fast on modest hardware
- Embedded and device software, such as solar controllers and sensors
- Game engines, simulations and scientific computing
Curriculum
Instructor-led, practical training. Each level is a block of 4, 8 or 12 weeks; every module ends with a practical activity and an assessment, and every level with a project.
Module 1: C++ Toolchain and First Programs 10 h
Install a compiler and editor, learn how source code becomes an executable, and write programs that calculate and print results. 3 lessons
Module 2: Control Flow and Functions in C++ 11 h
Make decisions and repeat work, then organise code into functions with value, reference and const reference parameters. 3 lessons
Module 3: Vectors, Arrays and Strings 10 h
Store collections of values with std::vector and std::array, work with text using std::string, and use standard algorithms such as std::sort. 3 lessons
Module 4: References, Pointers and First Classes 11 h
Understand memory addresses, references and pointers, and model real things with simple classes. 3 lessons
Module 5: C++ Console Project 10 h
Plan and build the Water Point Log as a multi-file program with a menu, validated input and a test record. 3 lessons
Level project: Water Point Log (console)
Module 1: Classes, Constructors and Object Lifetime 15 h
Write classes that initialise, copy and clean up correctly: constructors, destructors, const correctness, operator overloading and the rule of zero/three. 3 lessons
Module 2: Inheritance and Virtual Functions 15 h
Use inheritance for is-a relationships, virtual functions for runtime polymorphism and abstract base classes for interfaces, avoiding slicing and leaks. 3 lessons
Module 3: The Standard Template Library 16 h
Use STL containers, iterators and algorithms with lambdas to write shorter, faster and safer data-handling code. 3 lessons
Module 4: Files, Streams and Exceptions in C++ 14 h
Read and write files with streams, parse CSV text with stringstreams, and handle errors with exceptions and RAII. 3 lessons
Module 5: Builds and Debugging with CMake and GDB 13 h
Organise multi-file projects with CMake, debug with a debugger, and catch memory and undefined-behaviour bugs with sanitizers. 3 lessons
Module 6: Intermediate C++ Project 17 h
Build the Pharmacy Stock Manager from design to tested, sanitizer-clean CMake project and present it. 3 lessons
Level project: Pharmacy Stock Manager
Module 1: Templates and Generic Programming 22 h
Write function and class templates, constrain them with C++20 concepts and design generic algorithms in the style of the standard library. 4 lessons
Module 2: Modern Memory Management 24 h
Understand stack and heap memory, express ownership with smart pointers, and make types efficient to move. 4 lessons
Module 3: Modern C++17 and C++20 Features 20 h
Use the language and library features that make modern C++ clearer and safer: auto, structured bindings, optional, variant, string_view, constexpr and modern error handling. 4 lessons
Module 4: Testing and Performance in C++ 22 h
Write unit tests with a test framework, measure performance with profilers and benchmarks, and optimise based on evidence. 4 lessons
Module 5: Concurrency in Modern C++ 22 h
Run work in parallel with threads, protect shared data with mutexes and atomics, and use futures and parallel algorithms safely. 4 lessons
Module 6: C++ Capstone Project 30 h
Design, build, test, optimise and present the Offline Sensor Data Processor as a professional C++ project. 5 lessons
Level project: Offline Sensor Data Processor
Final practical project
Offline Sensor Data Processor
A command-line tool that validates and summarises large sensor logs in parallel and writes daily reports, designed to run on slow, offline computers.
Deliverables
- A CMake project with a tested library and a command-line executable
- Daily reports and an error summary for malformed input
- A parallel mode with a benchmark report
- A README with build, usage and test instructions
Assessed on
- Results are correct and identical in sequential and parallel modes
- No leaks, undefined behaviour or races under the sanitizers
- Performance claims are supported by repeatable measurements
- The project builds and runs from the README on another machine
Worked Examples
A selection of the visual, practical examples used in this program's lessons — each teaches a different skill.
- Workflow From source file to running program What the compiler toolchain does between typing g++ and running your program — and which stage reports which error. Beginner · Module 1 · Lesson 1
- Code example Mean and median minibus fares with std::vector Sort a list of fares and compare the mean with the median using standard algorithms. Beginner · Module 3 · Lesson 3
- Code example Counting requests with std::map Count how often each item appears in a list of requests and print the counts in alphabetical order. Intermediate · Module 3 · Lesson 2
- Code example Owning resources with unique_ptr Watch objects being created, ownership moving and destructors running automatically — no delete anywhere. Advanced · Module 2 · Lesson 2
- Troubleshooting tree Which way should this code hold that object? A quick path to the right choice between a value, a reference, unique_ptr, shared_ptr and weak_ptr. Advanced · Module 2 · Lesson 3
Free Course: C++ Starter
A free introduction to C++: compiling a first program, control flow and functions, arrays and strings, pointers and references, and simple classes. Free, self-study, about 6 hours — no certificate. The full program above is taught live by an instructor, with practical assignments, assessments and a certificate.
- 1Free lesson 1C++ Fundamentals & Setup
- 2Free lesson 2Control Flow & Functions
- 3Free lesson 3Arrays & Strings
- 4Free lesson 4Pointers, References & Classes
- 5Free lesson 5Problem Solving with C++
- Final checkQuick Quiz — C++ Basics
Tools & Technologies
Primary Tools
- GCC (g++), Clang or MSVC — A standards-compliant C++20 compiler for building every program in the course Practice: Compiling with warnings, choosing the language standard
- VS Code with C++ extension, or Visual Studio Community — Editing, building and debugging C++ code Practice: Navigating code, running and debugging programs
- CMake — The build system introduced at Intermediate level for multi-file projects and tests Practice: Writing CMakeLists.txt, debug and release builds
Supporting Tools
- GDB or the IDE debugger — Finding logic errors with breakpoints, stepping and the call stack Practice: Systematic debugging
- AddressSanitizer, UndefinedBehaviorSanitizer and ThreadSanitizer — Detecting memory errors, undefined behaviour and data races at run time Practice: Interpreting sanitizer reports
- Git — Version control for every project Practice: Committing, branching and sharing code
Professional / Industry Tools
- GoogleTest or Catch2 — Unit testing frameworks used at Advanced level Practice: Writing and organising automated tests
- perf or the Visual Studio profiler — Measuring where programs spend their time Practice: Profiling, benchmarking and evidence-based optimisation
Career Opportunities
- Junior C++ / systems developer
- Foundation for embedded systems or game development
- Performance-focused backend or tools developer
- Freelance developer for performance-sensitive projects
Practical Projects
- Build a small performance-conscious console application using STL containers throughout
- Refactor a raw-pointer program to use smart pointers and modern C++ practices
- Take a program using raw pointers and new/delete, refactor it to use smart pointers, and confirm there are no remaining memory leaks
Problem-Solving Focus
Problem: A program crashes with a segmentation fault, and it's unclear which part of the code actually caused it
Approach: Use a debugger (gdb) to find the exact line and inspect memory state at the crash, rather than guessing by inserting print statements everywhere.
Problem: Manually managing memory with new/delete leads to a memory leak or a double-free bug that's hard to track down
Approach: Prefer smart pointers (unique_ptr, shared_ptr) that automatically manage memory lifetime, instead of manual new/delete pairs that are easy to get wrong.
Problem: A function that worked with a small, fixed-size array breaks or behaves unpredictably when given more data than expected
Approach: Use std::vector instead of a raw C-style array so the container manages its own size safely, and add bounds checking where raw indexing is unavoidable.
Problem: A multi-file C++ project becomes hard to compile and rebuild correctly as it grows past one or two files
Approach: Use a build system like CMake to manage compilation dependencies, instead of manually typing increasingly complex compiler commands.
Ready to register for C++?
Register — Learn Online Register — Learn In Person WhatsApp: +211926196668 Email: rescueacademy26@gmail.com