C/C++ Programming

Understand the compile-link-run cycle, header files vs source files, and how to use gcc/clang/MSVC from the command line.

Learn primitive data types (int, char, float, double), variable declaration, arithmetic and bitwise operators, and implicit type conversions.

Master if/else, switch, for, while, do-while, break, and continue to direct program execution.

Define and call functions, understand pass-by-value, local vs global scope, and function prototypes.

You can write, compile, and run simple C programs with functions and control flow.

Understand memory addresses, pointer declaration, dereferencing, pointer arithmetic, and NULL pointers.

Work with fixed-size arrays, multidimensional arrays, and null-terminated character arrays for string handling.

Use malloc, calloc, realloc, and free to manage heap memory, and understand common pitfalls like leaks and dangling pointers.

Visualize how a program's memory is organized into text, data, BSS, stack, and heap segments.

You understand pointers, arrays, and manual memory management in C.

Define composite data types with structs, understand unions for memory-overlapping fields, and use enums for named constants.

Read from and write to files using fopen, fread, fwrite, fprintf, and understand text vs binary modes.

Use #include, #define, #ifdef, and macro functions; understand their power and pitfalls compared to real functions.

Split code across multiple .c and .h files, use header guards, and understand external linkage and static linkage.

Pass functions as arguments, build dispatch tables, and implement callback patterns in C.

You can build non-trivial, multi-file C programs with proper memory management.

Understand what C++ adds over C: references, function overloading, default arguments, namespaces, and the differences in compilation.

Define classes with member variables and methods, understand access specifiers (public, private, protected), and the this pointer.

Learn constructor overloading, initializer lists, destructors, and the RAII idiom for resource management.

Use lvalue references as aliases, overload operators for custom types, and understand the rule of three.

You can write class-based C++ code with proper resource management.

Derive classes, use virtual functions for runtime polymorphism, understand vtables, and apply the override keyword.

Define pure virtual functions, create interface-like abstract base classes, and design for extensibility.

Use try/catch/throw for error handling, understand exception safety guarantees, and know when exceptions are appropriate.

Use static_cast, dynamic_cast, const_cast, and reinterpret_cast correctly; understand runtime type information.

You can design and implement class hierarchies with proper polymorphism and error handling.

Understand lvalues vs rvalues, move constructors, move assignment, and std::move for efficient resource transfer.

Replace raw pointers with unique_ptr, shared_ptr, and weak_ptr to automate memory management and prevent leaks.

Write inline closures with capture lists, use std::function, and apply functional patterns like map/filter with algorithms.

Use type inference with auto, compile-time evaluation with constexpr/consteval, and structured bindings for cleaner code.

You write idiomatic modern C++ with move semantics, smart pointers, and lambdas.

Write generic code with templates, understand template instantiation, specialization, and common compile errors.

Use vector, map, unordered_map, set, deque, and array; understand their performance characteristics and when to choose each.

Traverse containers with iterators, apply STL algorithms (sort, find, transform, accumulate), and use ranges (C++20).

Use parameter packs for flexible APIs and C++20 concepts to constrain template parameters with readable error messages.

You can write and use templates effectively and leverage the full STL.

Configure builds with CMake or Make, manage dependencies, set compiler flags, and produce debug vs release builds.

Use gdb/lldb for step-through debugging, and AddressSanitizer/Valgrind to detect memory errors and leaks.

Create threads with std::thread, protect shared data with mutexes, use condition variables, and understand atomics and data races.

Understand BSD sockets, TCP/UDP basics, and write simple client-server programs in C/C++.

Apply C/C++ in resource-constrained environments: volatile, bitfields, memory-mapped I/O, and cross-compilation.

You can design, build, debug, and ship multi-file C/C++ projects with modern idioms and proper tooling.