Content

Course Content

Week 1: Introduction and Basic C++ Concepts

• Setting Up and Input/Output
  • Topics: input-output, include iostream, fstream, string
  • Example: Basic C++ program for reading and writing data.
• Variables and Basic Types
  • Topics: auto, nullptr,range-based
  • Example: Iterating over arrays and vectors with range-based for loops.

Week 2: Object-Oriented Programming Basics

• Introduction to Classes
  • Topics: class, constructor, destructor (implied)
  • Example: Simple class example with constructor and destructor.
• Operator Overloading and Function Overloading
  • Topics: operator_overloading, function_overloading
  • Example: Overloading the + operator for a custom Vector class.

Week 3: Memory Management

• Raw Pointers and Smart Pointers
  • Topics: raw_pointers, smart_pointers, std::unique_ptr, std::shared_ptr, reference
  • Example: Comparison of raw pointers vs. smart pointers in resource management.
• Deep Dive into std::unique_ptr and std::shared_ptr
  • Topics: std::make_unique, std::make_shared, std::weak_ptr
  • Example: Managing ownership in a multi-owner scenario with std::shared_ptr.

Week 4: Advanced OOP Concepts

• Virtual Functions and Polymorphism
  • Topics: virtual_function, polymorphism
  • Example: Implementing a polymorphic class hierarchy with base and derived classes.
• Abstract Classes and Dynamic Cast
  • Topics: abstract_class, dynamic_cast, override, final
  • Example: Creating an abstract base class and using dynamic_cast for safe downcasting.

Week 5: Templates and Generic Programming

• Introduction to Templates
  • Topics: templates, constexpr, decltype
  • Example: Writing a generic function template for a mathematical operation.
• Variadic Templates and Template Aliases
  • Topics: variadic_template, template_alias, using, typedef
  • Example: Implementing a variadic template function for summing numbers.

Week 6: The Standard Template Library (STL) Part 1

• Containers - array and vector
  • Topics: array, vector
  • Example: Dynamic array management using std::vector and fixed-size array with std::array.
• Associative Containers
  • Topics: unordered_map, std::unordered_set
  • Example: Implementing a simple hash table with std::unordered_map.

Week 7: The Standard Template Library (STL) Part 2

• Advanced Data Structures
  • Topics: list, tuple, std::pair
  • Example: Creating and managing linked lists and tuples for complex data grouping.
• Functional Objects and Bindings
  • Topics: std::function, std::bind, callbacks
  • Example: Using std::function and std::bind to implement callback mechanisms.

Week 8: Algorithms and Data Structures Part 1

• Binary Trees and Binary Search Trees
  • Topics: binary_tree, binary_search_tree
  • Example: Implementing binary search in a custom binary search tree.
• Linked Lists
  • Topics: single_linked_list, double_linked_list
  • Example: Implementing a singly linked list from scratch.

Week 9: Algorithms and Data Structures Part 2

• Heaps and Queues
  • Topics: heap, queue
  • Example: Implementing a priority queue using a binary heap.
• Recursion and Stack Frames
  • Topics: recursion, stack_frame
  • Example: Implementing recursive algorithms and understanding call stack.

Week 10: Modern C++ Features Part 1

• Move Semantics
  • Topics: move_semantics, std::move, std::forward
  • Example: Implementing move constructors and move assignment operators.
• Universal References and Rvalue References
  • Topics: universal_reference, forward_reference, lvalue, rvalue
  • Example: Handling universal references in function templates.

Week 11: Modern C++ Features Part 2

• Lambda Expressions
  • Topics: lambda,
  • Example: Using lambda expressions for inline function definitions.
• Exception Handling
  • Topics: std::exception_ptr, noexcept
  • Example: Safely managing exceptions with std::exception_ptr.

Week 12: Multithreading and Concurrency Part 1

• Introduction to Multithreading
  • Topics: thread, mutex, std::lock
  • Example: Creating and managing threads, using mutexes to avoid race conditions.
• Atomic Operations
  • Topics: atomic, memory_order
  • Example: Implementing a simple atomic counter with std::atomic.

Week 13: Multithreading and Concurrency Part 2

• Advanced Concurrency
  • Topics: std::async, std::scoped_lock, std::shared_mutex
  • Example: Using std::async for asynchronous tasks and std::shared_mutex for read/write locks.
• Timers and Time Management
  • Topics: timers, std::chrono
  • Example: Measuring execution time of code using std::chrono.

Week 14: Miscellaneous Topics and Final Review

• Type Identification and Type Safety
  • Topics: static_cast, dynamic_cast, constant_cast, reinterpret_cast, type_identification
  • Example: Safe casting techniques and runtime type identification.
• Final Review and Q&A
  • Topics: Review of key concepts.
  • Example: Revisiting difficult concepts and solving complex problems collaboratively.