C++ Tutorial

Meet modern C++ and how this InTelleX path is organized.

Set up g++/clang++ and verify your toolchain.

Write, compile, and run a tiny program end to end.

int, double, char, bool, and type safety basics.

Use const and constexpr for safer values.

Arithmetic, comparison, logical, and assignment operators.

cin, cout, and formatting basics.

if, else if, else, and switch.

for, while, and do-while with clear examples.

Declare, define, and call functions with parameters.

Multiple functions with the same name and different signatures.

Provide optional parameters with defaults.

Fixed-size arrays and common pitfalls.

Create, concatenate, and inspect strings.

Dynamic arrays with push_back and size.

Iterate containers cleanly with for-each style loops.

Alias variables and pass by reference.

Addresses, dereference, and nullptr.

Dynamic allocation and why modern C++ prefers RAII.

Group related data into simple types.

Encapsulation with public and private members.

Initialize objects and clean up resources.

Define behavior on your types.

Split declarations and definitions across files.

Build a small calculator using functions and loops.

Design classes with clear public APIs.

Derive classes and reuse behavior.

Call the right method through base pointers.

Pure virtual functions and interfaces.

Define +, ==, and stream operators carefully.

Containers, iterators, and algorithms map.

Associative containers for keys and unique values.

sort, find, accumulate, and transform.

Traverse containers with begin/end idioms.

Inline function objects for algorithms.

Let the compiler deduce types safely.

Own resources without manual delete.

std::move and rvalue references at a practical level.

try/catch and when not to throw across APIs.

Read and write text files with fstream.

Organize symbols and avoid collisions.

Build multi-file projects with CMake.

Breakpoints, backtraces, and inspecting variables.

Structure small tests for functions and classes.

Write generic functions with templates.

Generic containers and utility types.

Build a gradebook with classes, vectors, and file save.

CRUD todos with persistence.

Resource acquisition is initialization as a design rule.

Copy/move constructors and assignment operators.

Design APIs that cannot mutate by accident.

std::thread and joining workers.

Protect critical sections with std::mutex.

When lock-free counters make sense.

Measure first: cache locality, copies, and allocations.

-O2, -O3, and debug vs release builds.

Recognize UB and write defined programs.

Catch memory and UB bugs early.

Factory, Strategy, and Observer in practical form.

Sockets at a high level for systems apps.

Constraints: no heap thrash, careful types, predictability.

Parse request lines and headers from a buffer.

Queue tasks and run them on worker threads.

Pointers, OOP, STL, and move semantics checklist.

Where to go: Boost, graphics, embedded, or distributed systems.