C++

Evaluate arithmetic expressions using C++ precedence rules.

Predict the results of integer division, floating-point division, and remainder operations.

Construct Boolean expressions with comparison and logical operators.

Select between two execution paths with if and else.

Represent multi-branch decisions with else-if chains.

Implement menu choices with a switch statement.

Use the Visual Studio debugger to inspect variables in a branching program.

Build a menu-driven calculator that rejects unsupported operations.

Repeat statements with a while loop.

Use a do-while loop when a task must execute before its condition is checked.

Implement count-controlled repetition with a for loop.

Compute running counts, totals, minimums, and maximums inside loops.

Control loop execution with break and continue.

Generate bounded random integers with the C++ random library.

Repeat input until the user supplies a valid value.

Build a number-guessing game with hints and a limited number of attempts.

Declare, define, and call a function.

Pass input values to a function using parameters passed by value.

Return a computed result from a function.

Predict variable visibility and lifetime from C++ scope rules.

Prevent unintended modification by applying const to local values and parameters.

Pass a value by reference when a function must modify the caller's object.

Pass read-only objects by const reference to avoid unnecessary copying.

Refactor the number-guessing game into single-purpose functions.

Create, concatenate, compare, and inspect std::string values.

Read complete text lines with std::getline after formatted console input.

Normalize and classify characters with standard character-handling functions.

Create a std::vector and safely access its elements.

Add and remove vector elements while tracking the vector's size.

Process every element of a vector with a range-based for loop.

Search and filter a vector according to a stated condition.

Build a text analyzer that reports line, word, character, and selected-word counts.

Group related values into a struct and create struct objects.

Represent a fixed set of named states with enum class.

Define a class with public behavior and private data.

Initialize class data with a constructor initializer list.

Write const member functions that do not modify object state.

Separate a class declaration and implementation into header and source files.

Store and update class objects in a std::vector.

Build an in-memory inventory application that adds, lists, searches, and updates products.

Use a reference as an alias for an existing object.

Obtain an object's address and access it through a pointer.

Detect and avoid dereferencing null pointers.

Trace automatic object lifetime by observing constructor and destructor calls.

Explain the ownership risk created by manual new and delete operations.

Create exclusive dynamic ownership with std::unique_ptr.

Transfer a std::unique_ptr with move semantics.

Choose among values, references, and smart pointers for simple ownership scenarios.

Derive a specialized class from a base class.

Initialize inherited state by calling a base-class constructor.

Override virtual behavior in a derived class.

Define an abstract interface with a pure virtual function.

Enable safe polymorphic destruction with a virtual destructor.

Store different derived objects in a vector of std::unique_ptr to the base type.

Choose composition instead of inheritance when objects have a has-a relationship.

Build a shape-reporting program that processes multiple shape types polymorphically.

Associate unique keys with values using std::map.

Use std::unordered_map for lookup when sorted key order is unnecessary.

Represent unique values with std::set.

Traverse a standard container with iterators.

Write a lambda expression that captures local state.

Sort objects with std::sort and a custom comparison.

Query collections with std::find_if and std::count_if.

Add category summaries and ranked reports to the inventory application with standard containers and algorithms.

Open a text file and verify that the stream is usable.

Write structured application data with std::ofstream.

Read a text file line by line with std::ifstream.

Parse a simple delimited record into typed fields.

Report recoverable failures with return values or std::optional.

Throw and catch a standard exception at an appropriate program boundary.

Construct and inspect Windows file paths with std::filesystem.

Add save-on-exit and load-on-start persistence to the inventory application.

Interpret common C++ compiler diagnostics and fix the first reported root error.

Enable and respond to high-value compiler warnings in Visual Studio.

Use breakpoints, step controls, call stacks, and watches to locate a defect.

State a function's normal, boundary, and invalid-input test cases.

Implement repeatable checks for a pure function with assertions.

Use AddressSanitizer in Visual Studio to detect an invalid memory access.

Write a reusable function template for an operation shared by multiple types.

Configure and build a small multi-file C++ project with CMake.

Define a small management application's users, core features, and acceptance criteria.

Model the application's entities and states with classes, structs, and enum classes.

Design a command loop that maps validated menu choices to application operations.

Implement create, view, update, delete, search, and sort operations over the data model.

Persist the application's data in a documented text-file format.

Handle invalid input, missing records, and file failures without terminating unexpectedly.

Verify core operations with normal, boundary, and invalid-input test cases.

Refactor, document, and produce a warning-free release build of the application.