Modern C++20 Bootcamp: Basics to Advanced C++ Multithreading

Modern C++, C++20, advanced C++ multithreading, concurrent data structures, memory models for high-performance programs

  • 0.0 (0 Reviews)
  • 0 Students
  • 575 Lessons
  • RougeNeuron Academy

Course Overview

This course is your comprehensive pathway to mastering modern C++ development. This expertly crafted, almost 24-hour course transforms foundational knowledge into professional-grade programming skills, featuring cutting-edge C++20 features and industry-standard multithreading practices used by top tech companies.


Master three essential pillars of professional C++ development:


1. Modern C++ Mastery

- Latest C++20 features and best practices

- Powerful object-oriented programming techniques

- Professional-grade STL implementation

- Smart memory management for leak-free code

- Industry-standard error handling strategies


2. Professional Development Skills

- Advanced template programming techniques

- High-performance STL algorithms

- Production-ready I/O handling

- Generic programming for scalable solutions

- Modern string processing and regex mastery


3. Enterprise-Level Threading

- Production-tested multithreading patterns

- Advanced memory models and synchronization

- High-performance lock-free programming

- Thread-safe data structure design

- Performance optimization secrets


What sets this course apart:

- 300+ carefully structured video lectures

- 150+ Real-world coding exercises

- Strategic knowledge-check quizzes

- Overview of using essential production tools (CMake, Git, debugging) in context of C++

- A performance tools overview with demos.

- Industry-relevant project examples


Perfect for ambitious developers with basic programming knowledge, this course requires only a desktop browser - no complex IDE setup is needed!


Whether you're aiming to build high-performance applications, ace technical interviews, or modernize legacy systems, this course delivers the practical skills needed in today's competitive tech landscape. Join thousands of successful students who've transformed their C++ development capabilities through this comprehensive learning journey. (Please watch the course overview for a detailed course roadmap.)


More Details about Intermediate and Advanced Content:

This intermediate-level content covers advanced concurrency and memory models in C++, focusing on writing high-performance concurrent programs. Students will explore the C++ memory model, including Sequential Consistency-Data Race Free (SC-DRF) guarantees, memory barriers, and atomics. The material delves into efficient synchronization mechanisms, lock-free and wait-free algorithms, and techniques for avoiding performance pitfalls like false sharing in caches.

The modules emphasize the practical implementation of concurrent data structures using modern C++20 features, including parallel algorithms, atomic operations, and enhanced memory models. Students will learn to design and implement thread-safe data structures like queues, stacks, hash tables, and trees, while mastering essential performance analysis tools such as perf, Valgrind, Intel Vtune, Google Orbit, and gdb. This content is particularly suited for experienced C++ developers looking to enhance their concurrent programming skills and create scalable applications for multi-core systems.


Note: While accessible to beginners, this course rewards dedicated learners ready to master professional C++ development.


Student Review

So, I'm a software developer who has been working in C++ for over two decades now (gods I am old) - but I have to do periodic training for work and somehow HR approved me taking this course for my on going training. I intended to leave it on in the background and just get on with work - but then I started to notice the quality of the instructors lessons and started paying attention because this could be something good to give to our new interns. I will say outright the only reason it is not a full 5 stars is because some of the exercises are worded a bit weirdly that even I had to see the test output to get exactly what the instructor wanted from us - however, the material is very good and gives enough depth to be complete but not so much as to confuse new people (especially with the difficulties listed before each section). If someone worked through this course, practised and studied on their own as well, and did the capstone project they would be more than prepared to seek internships as a C++ developer. The course is well structured, presentation is thorough, and the instructor seems well versed in best practises and general programming. Great work!

See more

FAQ

FAQ area empty

Course curriculum

55 chương 575 bài học 23 giờ 51 phút 7 bài học thử miễn phí
Chương 1 Introduction
Chương 2 [Absolute Beginner] Getting started with C++ and basic learning online tools
Chương 3 Course Project - Start with the bigger picture in mind
  • What are the five stages of the C++ capstone key-value store project? 25:10
Chương 4 [Beginner] Basic Features of C++ present in all C++ programs
  • What syntax declares a C++ function and how does the compiler use it? Học thử 2:50
  • Basic function coding exercise
  • How does function overloading work and how does the compiler resolve it in C++? 5:06
  • Function variations
  • How does the C++ type system define constraints on declared entities? 6:51
  • Using types to create variables in a program
  • How do arithmetic operators and type conversions work in C++? 4:22
  • Arithmetic operators
  • How does braced init prevent narrowing and when should auto be avoided in C++? 6:55
  • Initialization of variables
  • Using auto keyword
  • How do the five C++ scopes determine the lifetime of entities? 4:51
  • Scopes and life times of objects in programs
  • What are the differences between const, constexpr, and consteval in C++? 8:39
  • Const correctness
  • How are arrays, pointers, and references declared and used in C++ programs? 8:19
  • Array pointers references
  • How does nullptr improve null pointer safety over NULL and 0 in modern C++? 5:19
  • Using nullptr
  • How do pointer and reference assignment differ in C++ hardware terms? 11:14
  • How do if-else, switch, for, and while implement control flow in C++? 7:12
  • If-else statements
  • Switch case statements
  • Using while loops
  • Section Quiz
Chương 5 [Beginner] User Defined Types in Modern C++
  • What is the distinction between built-in and user-defined types in C++? 3:02
  • Builtin type checker. Applying the basics.
  • How are C++ structs defined and accessed through value, reference, and pointer? 6:58
  • Using Structures in C++
  • How do access specifiers, constructors, and member functions define a C++ class? 12:13
  • Working with classes
  • How does enum class provide stronger type safety compared to plain enum in C++? 7:44
  • Working with Enumerations in modern C++
  • How does std::variant improve on raw unions for type-safe storage in C++? 6:37
  • Using std::variant
  • Section Quiz
Chương 6 [Beginner] Modularity
  • What is the One Definition Rule and how does it govern declarations in C++? 4:59
  • ODR in practice
  • How does the C++ header file mechanism enable separate compilation? 7:55
  • Working with Header files
  • How do C++20 modules improve on header files for dependency and performance? 5:54
  • How are C++ namespaces declared and when does using namespace cause conflicts? 4:41
  • Working with namespaces in C++
  • How do pass-by-value, pass-by-reference, and const reference differ in C++? 6:27
  • Argument passing scenarios
  • What are the syntax options for returning values from C++ functions? 8:40
  • Returning values in functions of C++ programs
  • Using structured bindings ( C++17 feature )
  • Section Quiz
Chương 7 [Beginner] Error Handling in C++
  • Why does C++ error handling require a strategy beyond just language facilities? 2:56
  • How does C++ try-catch throw exceptions, unwind the stack, and catch errors? 8:25
  • Working with exceptions
  • What is a C++ class invariant and how does the constructor enforce it? 4:56
  • Understanding the role of invariants in programs.
  • When should C++ functions use exceptions, error codes, or termination? 12:45
  • Using various error handling alternatives in programs
  • How do assert, static_assert, and noexcept enforce invariants in C++? 11:07
  • Intergrating assertion in C++ programs
  • Section Quiz
Chương 8 [Beginner] Classes
  • What are the three fundamental C++ class types and their uses? 2:58
  • What makes a C++ class concrete and what are its trade-offs vs abstract types? 3:16
  • How do constructors, const members, and operator overloading define a C++ type? 6:34
  • Implementing the complex number.
  • How does a C++ destructor release heap memory and what does initializer_list do? 4:33
  • How do pure virtual functions create abstract classes in C++? 9:10
  • Using abstract types in C++ programs
  • How does the C++ vtable enable runtime dispatch and what is its overhead? 5:01
  • How do dynamic_cast and unique_ptr work in C++ class hierarchies? 8:30
  • Working with class hierarchies in C++
  • How do C++ class hierarchies chain constructors and manage destructors? 8:49
  • Section Quiz
Chương 9 [Beginner] Essential operations with classes necessary to build programs
  • What are C++'s seven special member functions and when are they auto-generated? 9:38
  • Implementing essential operations
  • How do copy and move constructors handle shallow copy and ownership in C++? 10:46
  • Using move sematics for efficient copying.
  • What is RAII in C++ and how do smart pointers ensure resource safety? 6:25
  • Which C++ operators can be overloaded as member vs freestanding functions? 2:58
  • Implementing operator overloading in user defined classes
  • How do C++ comparison and spaceship operators work for user-defined types? 7:43
  • What conventional operations should C++ container types implement? 8:09
  • Working with spaceship operator ( C++20 )
  • Implementing a simple hashing function
  • How are user-defined literals declared in C++ using operator"" suffix syntax? 6:20
  • Implementing User defined literals
  • Section Quiz
Chương 10 [Intermediate] Templates
  • What is the C++ template mechanism and how does it enable generic types? 7:10
  • Working with parameterized types
  • How do C++20 concepts constrain template type arguments and non-type parameters? 3:54
  • Working with Concepts ( C++20)
  • When does C++ template argument deduction fail and what are deduction guides? 6:35
  • Template argument deduction in practice
  • How are C++ function templates and functors used as generic algorithms? 6:25
  • Using function template and function objects in programs
  • How are C++ lambda expressions declared and what do capture modes mean? 8:09
  • Using lambda expressions in your C++ programs.
  • How do alias templates and if constexpr enable compile-time branching in C++? 4:55
  • Working with aliases
  • Section Quiz
Chương 11 [Advanced] Concepts ( C++20) and Generic Programming
  • What techniques do C++ templates enable and why are they essential for generics? 4:53
  • Why do C++ templates need concepts to replace unconstrained typename parameters? 6:19
  • How do C++20 concepts express cross-parameter compatibility in templates? 4:33
  • How does C++ concept-based overloading select templates and resolve ambiguity? 4:44
  • Implementing concepts based overloading (C++20)
  • How does the requires clause differ from a requires expression in a C++ concept? 1:34
  • How are C++20 concepts defined with concept keyword and requires expressions? 10:58
  • Creating concepts ( C++20 )
  • How does auto relate to C++20 concepts and why use constrained parameters? 5:18
  • What is generic programming and how do concepts lift C++ algorithms to generic? 10:09
  • How are C++ variadic templates declared and what are their compile-time risks? 8:25
  • Using parameter packs and variadic templates
  • How do C++17 fold expressions simplify variadic template unpacking? 8:29
  • Working with Fold expressions ( C++17)
  • Section Quiz
Chương 12 [Beginner] C++ Standard Library Overview
  • What is the C++ Standard Library and why consult it before writing custom code? 3:52
  • What are the major C++ Standard Library components and what does each cover? 10:36
  • How is the C++ Standard Library organized and why avoid using namespace std? 7:55
  • Multiple header issues and solving them
  • Section Quiz
Chương 13 [Beginner] Strings and Regular Expressions
  • When should std::string, string_view, or regex be used for C++ text processing? 2:33
  • What operations does C++ std::string provide for manipulation and comparison? 9:23
  • C++ String class interface and operations
  • How does std::string implement short string optimization and basic_string? 4:01
  • When should std::string_view replace std::string in C++ function parameters? 4:59
  • Using string_view in programs (C++17)
  • What classes and functions does C++ provide and how do they differ? 3:56
  • How do C++ regex greedy vs non-greedy quantifiers and character classes work? 9:54
  • Working with std::regex
  • Section Quiz
Chương 14 [Intermediate] Input and Output facilities in C++
  • What are C++ I/O stream facilities and how do ostream and istream work? 2:01
  • How does C++ ostream handle cout chaining and char-vs-int implicit conversion? 2:25
  • How do C++ operator>> and getline parse different input types from std::cin? 3:19
  • How does C++ istream state (eof, fail, bad) enable robust input error handling? 2:18
  • How do you overload operator<< and operator>> in C++ for user-defined types? 3:29
  • Writing input output opreatios for User defined Types.
  • How do C++ stream manipulators and setprecision control output formatting? 4:32
  • How does C++20 std::format differ from printf and what format specifiers apply? 8:30
  • Working std::format feature shipped with C++20
  • What are the standard, file, string, and synchronized C++ stream types and uses? 10:39
  • Working with string streams
  • How does C++ provide portable path and directory management? 12:57
  • Filesystems ( C++17)
  • Section Quiz
Chương 15 [Intermediate] Container (STL/ Standard Template Library)
  • What is a C++ STL container and why are collections essential for programs? 1:36
  • How does std::vector manage capacity and handle iterator invalidation in C++? 17:38
  • When should std::list replace std::vector and how do insert and erase work? 4:56
  • Working with vector, list and forward_list
  • What is C++ std::map's O(log n) lookup and the side effect of operator[]? 2:37
  • Working with std::map and std::set
  • When to use std::unordered_map over std::map and how to implement a custom hash? 4:24
  • Using the hash map and hash set in C++
  • How do C++ pool allocators and std::pmr improve container memory performance? 8:19
  • How do C++ STL container categories compare and when to use emplace_back? 14:35
  • Section Quiz
Chương 16 [Intermediate] Algorithms (STL/Standard Template Library)
  • How do C++ STL algorithms use half-open sequences and back_inserter for output? 6:50
  • How do C++ STL algorithms use iterators to separate logic from containers? 4:44
  • Working with iterators and STL algorithms
  • How do C++ iterator types differ by container and what iterator concepts exist? 11:49
  • How do functors and lambdas define predicates for C++ STL algorithms? 2:11
  • Using predicates with STL algorithms
  • What do for_each, find, count, sort, merge, and equal_range do in C++ STL? 11:16
  • How do C++ execution policies request parallel and vectorized STL execution? 7:38
  • Section quiz
Chương 17 [Intermediate] Ranges ( C++20)
  • How do C++20 ranges generalize iterator pairs with sentinel and concept safety? 3:13
  • What are C++ standard library range views and how do they differ from ranges? 8:18
  • What C++ standard library range generators produce sequences on demand? 3:01
  • Working with ranges and generators ( C++20 )
  • How does the C++ range pipe operator chain views for lazy sequence processing? 2:29
  • What are the C++ standard library concept categories for types and iterators? 6:59
  • Section Quiz
Chương 18 [Beginner/Intermediate] Pointers and Container (non STL)
  • What is the role of C++ smart pointers and how do they relate to containers? 2:16
  • What are C++ pointer types and how does owning vs non-owning distinguish them? 7:40
  • How do C++ unique_ptr and shared_ptr implement RAII and when to choose each? 11:57
  • Using unique_ptr and shared_ptr in C++ programs to make them safer.
  • How does C++ std::span replace pointer-count pairs and prevent range errors? 6:23
  • Using spans instead of old C-style array passing (C++20)
  • What are the C++ non-STL containers array, bitset, pair, and tuple? 17:42
  • Working with pair and tuple in C++ programs
  • How do std::variant, optional, and any replace unions safely in C++? 8:59
  • Working with std::variant and std::optional ( C++17 )
  • Section Quiz
Chương 19 [Intermediate] Utilities provided by C++ standard library
  • What C++ standard library utilities exist beyond containers and algorithms? 2:14
  • How do C++ chrono clocks, durations, and zoned_time handle portable time? 9:29
  • Applying chrono utilities in your programs
  • How do lambdas, mem_fn, and std::function adapt callables in C++ algorithms? 3:49
  • Applying function adaption
  • What are C++ type traits and how do they enable compile-time type decisions? 9:50
  • Using Type functions in your programs
  • How does C++20 std::source_location provide file and line info without macros? 2:02
  • What does std::move do in C++ and when should std::forward be used instead? 5:31
  • Working with move and forward semantics to leverage the power of Modern C++
  • What does the C++ header provide and when should bit_cast be used? 2:43
  • What are the C++ exit functions std::exit, abort, quick_exit, and terminate? 5:30
  • Section Quiz
Chương 20 [Intermediate] Numerics in C++ standard library
  • What math functions does the C++ standard library provide and their limitations? 2:57
  • What numerical algorithms does C++ provide and how do predicates work? 1:30
  • Utilizing the numerical algorithms available in C++ standard library
  • How does the C++ random number facility separate engine from distribution? 2:26
  • Using random number facilites provided in modern C++
  • How do C++ valarray, numeric_limits, and fixed-width integer types work? 2:19
  • Using valarray in C++ programs for vector arithmetic
  • Section Quiz
Chương 21 [Beginner] Concurrency / Multithreading from Operating Systems perspective
  • What common myths about multithreading lead to incorrect C++ program design? 4:10
  • Myths busted
  • Why do no generic solutions exist for concurrent C++ programming? 2:06
  • How do multitasking, multithreading, concurrency, and parallelism differ? 5:54
  • What are process, thread, heap, and stack in C++ concurrent programs? 5:15
  • How do hardware cores and hyperthreading determine C++ thread parallelism? 5:00
  • Quick Knowledge Check
  • What is a resource in concurrent C++ and how do race conditions arise? 4:10
  • How do CPU caches and NUMA nodes affect multithreaded C++ memory performance? 6:26
  • How does a context switch enable time slicing between concurrent threads? 8:25
  • How do production environments shape C++ concurrency design decisions? 3:47
  • How does Amdahl's Law set the upper bound on concurrent C++ program speedup? 5:07
  • Amdahl's law in practice
  • When is multithreading the appropriate solution in C++ software design? 5:29
  • How do C++ features travel from the ISO standards committee to shipping code? 7:40
  • How has C++ standard library concurrency support evolved from C++98 to C++20? 4:04
Chương 22 [Intermediate] Quick look at Concurrency and Multithreading using Modern C++20
  • What C++ standard library concurrency features does this section introduce? 3:39
  • What is the distinction between a task and a thread in concurrent C++? 4:04
  • How do C++ threads receive arguments and return values to the calling thread? 2:45
  • A simple concurrent program using Modern C++ concurrency constructs
  • Passing data and getting back results from concurrent programs in C++
  • How do mutex, scoped_lock, and shared_mutex synchronize shared data in C++? 6:18
  • Using mutex and lock to share data between threads without corruption.
  • How does std::condition_variable enable event-based waiting in C++? 8:38
  • Using condition variables in programs (C++14)
  • How do std::future and std::promise transfer values between concurrent tasks? 11:55
  • Using futures in C++ programs
  • Section Quiz
Chương 23 [Intermediate] Managing threads with Modern C++ (C+11 onwards upto C++20)
  • How are C++ threads launched with std::thread and std::jthread syntax? 4:33
  • How are arguments passed to C++ thread and jthread function parameters? 0:52
  • What are the member functions of std::thread and std::jthread in C++? 4:45
  • Threads member function Quiz
  • How does std::stop_token enable cooperative thread cancellation in C++20? 3:35
  • How does std::stop_source coordinate cooperative cancellation across threads? 3:07
  • Cooperative Cancellation Quiz
  • What ownership and copying pitfalls arise when passing data to C++ threads? 2:52
  • When should std::async be used instead of std::thread in C++? 3:09
  • Async vs thread?
Chương 24 [Intermediate] Synchronization in multhreaded application using C++ concurrency
  • What synchronization mechanisms does C++20 provide to prevent data races? 0:55
  • What is std::latch in C++20 and how does it synchronize multiple threads? 1:27
  • How is std::latch used to synchronize threads in C++20? 3:00
  • How can std::latch coordinate test thread startup in multithreaded C++? 2:24
  • Std::latch quiz
  • What is std::barrier in C++20 and how does it differ from std::latch? 0:55
  • How is std::barrier constructed and used with arrive_and_wait in C++20? 3:41
  • When should std::barrier be used for loop synchronization in C++20? 1:19
  • Std::barrier quiz
Chương 25 [Intermediate] Futures in multithreading (C++11 onwards)
  • What are C++ futures and how do async, promise, and packaged_task use them? 2:10
  • What are the member functions of std::future and when is each used in C++? 2:13
  • How do blocking and polling differ when retrieving results with std::future? 1:46
  • Std::future Quiz
  • What are the member functions of std::promise and when should each be used? 1:56
  • How are std::promise and std::future paired to pass data between threads? 1:58
  • How does std::promise propagate exceptions to a waiting std::future? 0:33
  • Using futures in programs
  • Why is std::future single-use and when does std::shared_future replace it? 0:49
  • How does std::shared_future broadcast a single result to multiple threads? 0:45
  • Shared futures in action
  • How does std::async function as a high-level concurrency mechanism in C++? 1:14
Chương 26 [Intermediate] Mutex and lock for safe multithreading ( C++11 onwards)
  • What mutex types does C++ provide and when should each be used? 3:55
  • How do scoped_lock, unique_lock, and lock_guard manage mutex lifetime in C++? 2:48
  • How does std::scoped_lock prevent deadlocks when acquiring multiple mutexes? 3:52
  • Locks and mutexes
Chương 27 [Intermediate] Conditional Variables ( C++11 onwards )
  • Why is busy waiting for shared data between threads harmful in C++? 2:26
  • How does std::condition_variable eliminate busy waiting between C++ threads? 2:34
  • How does std::condition_variable_any integrate stop_token in C++20? 1:46
  • Conditional Variables Quiz
Chương 28 [Intermediate] Semaphore (C++20 onwards)
  • What is a semaphore in C++20 and how does it differ from a mutex? 2:41
  • What are the member functions of std::counting_semaphore in C++20? 1:36
  • How is std::counting_semaphore used to limit concurrent thread access in C++? 1:36
  • Sempahores Quiz [C++20]
Chương 29 [Intermediate] Atomics ( C++11 onwards)
  • What are C++ atomics, what types can they hold, and are they always lock-free? 6:30
  • Which C++ atomic operator overloads are atomic and which cause compiler errors? 3:25
  • Why is ++x atomic but x = x + 1 not atomic on std::atomic variables in C++? 1:50
  • Which operations are guaranteed atomic on std::atomic types in C++? 1:37
  • What do load, store, exchange, and fetch_add do on std::atomic variables? 4:58
  • What are the key rules for correctly using std::atomic operator overloads? 1:58
  • C++11 Atomics Operators Quiz (might need additional look at reference docs!)
Chương 30 [Intermediate] Parallel Algorithms ( since C++17)
  • How do C++17 parallel algorithms and execution policies extend std::sort syntax? 2:06
  • What are the caveats and pitfalls of C++17 parallel execution policies? 3:06
  • How does a parallel algorithm allocate threads across hardware cores in C++17? 1:02
Chương 31 [Advanced] Coroutines feature quick overview ( as shipped in C++20)
  • Why are C++20 coroutines considered incomplete for production before C++23? 1:48
  • Coroutines Quiz
  • How does control transfer between a caller and a C++20 coroutine? 4:06
  • What API sequence does the C++20 coroutine task structure use from start to end? 4:38
  • What is the C++20 coroutine execution flowchart showing API call sequence? 1:49
Chương 32 [Advanced] Modern C++ Memory Model Deep Dive (Features Available since C++11)
  • What hardware model assumptions underlie the C++ memory model lectures? 1:10
  • What does the C++ memory model guarantee when there are no race conditions? 3:13
  • What external factors cause C++ programs to execute differently than written? 6:35
  • What is sequential consistency in C++ and why must it be explicitly requested? 1:13
  • Knowledge Check
  • What is a data race in C++ and what constitutes a memory location? 2:52
  • What is SC-DRF and how does it govern the contract between C++ and the hardware? 2:57
  • How does the C++ memory model constrain compiler and hardware transformations? 4:51
  • Knowledge Check
Chương 33 [Advanced] Code Optimizations: Behind the scenes [C++ Memory Model]
  • Why can atomic flags without ordering fail to protect a critical section? 4:35
  • How do CPU store buffers enable race conditions in multithreaded C++ programs? 2:46
  • How do dead-store elimination and reordering in C++ break multithreaded code? 3:06
  • What is the general strategy for safely optimizing concurrent C++ code? 2:39
  • Knowledge Check
Chương 34 [Advanced] Concurreny with Barriers in C++ Memory Model
  • How does the C++ memory model provide transactional guarantees for shared memory 4:07
  • What are the three mechanisms C++ provides for protecting a critical section? 4:09
  • Why can code not be moved out of a C++ critical section by the compiler? 2:18
  • What code can be safely moved into or reordered within a C++ critical section? 2:40
  • Knowledge Check
  • What are acquire and release barriers in C++ memory models and how do they work? 2:49
  • When should you use a full memory barrier versus acquire/release in C++? 2:19
  • How does sequential consistency prevent acquire and release barriers crossings? 2:32
  • What are the key takeaways for using memory barriers in concurrent C++ code? 3:06
  • How do pipelining, caching, and speculation affect concurrent C++ code? 7:35
  • Knowledge Check
Chương 35 [Advanced] Performance analysis of atomics data types in C++ Memory Model
  • Why must atomic vs lock performance always be measured rather than assumed? 3:10
  • Does splitting atomic variables across threads actually improve C++ performance? 0:46
  • Why does struct size affect whether std::atomic is lock-free in practice? 5:01
  • Why do atomic write operations wait for each other across CPU cores in C++? 3:48
  • What is false sharing in C++ multithreading and how can you avoid it? 2:56
  • Knowledge Check
Chương 36 [Advanced] Compare and Swap supported by modern C++ Model
  • How does compare_exchange_strong work as a lock-free synchronization primitive? 3:09
  • What is difference between compare_exchange_strong and compare_exchange_weak? 2:12
  • How is compare_exchange_strong used to implement atomic actions on std::atomic? 2:23
  • What is the pseudocode implementation of compare_exchange_strong in C++? 2:35
  • How can compare_exchange_strong be optimized to reduce locking overhead? 3:35
  • Why does compare_exchange_weak return false even when the expected value matches 2:45
  • Knowledge Check
Chương 37 [Advanced] Memory ordering in multithreading with Modern C++ memory model
  • What role do memory orderings play in C++ atomic synchronization? 2:48
  • What are the key nuances of C++ memory barriers and where do they come from? 3:27
  • How did C++11 make memory barriers portable through atomic operation syntax? 1:55
  • What does memory_order_acquire guarantee about code reordering in C++? 2:26
  • Knowledge Check
  • What does memory_order_release guarantee about code reordering in C++? 2:42
  • How do paired acquire and release barriers synchronize two threads in C++? 3:17
  • How do acquire and release barriers implement an atomic lock replacement in C++? 2:49
  • What are memory_order_acq_rel and memory_order_seq_cst barriers in C++? 2:15
  • Why does compare and exchange in C++ have two parameters for memory ordering? 1:43
  • What is the default memory order in compare and swap? 3:26
  • Knowledge Check
Chương 38 [Advanced] Memory Order: Software Design and performance considerations
  • Why would a C++ programmer explicitly specify memory order on atomic operations? 2:22
  • How does explicit memory_order communicate programmer intent in C++ atomics? 2:36
  • What does memory_order_relaxed on std::atomic::fetch_add mean in C++? 2:45
  • How does memory_order_release on an atomic counter signal data readiness in C++? 1:43
  • What does using std::atomic with default memory order signal about code intent? 1:02
  • Knowledge Check
  • How do memory barriers impact performance across different hardware platforms? 3:29
  • Is sequential consistency always slower than acquire/release in C++ atomics? 2:03
  • Why are platform-specific memory barriers inferior to C++ memory_order? 2:04
  • What are the key design guidelines for using std::atomic correctly in C++? 2:10
  • When is it appropriate to use std::atomic instead of a mutex in C++? 3:16
  • Knowledge Check
Chương 39 [MUST WATCH] Intro to tools for analyzing Concurrent programs (not just in C++)
  • [WARNING] Before diving into tools
  • What profiling tools are demonstrated for concurrent C++ performance analysis? 3:03
  • How does the Linux top command monitor threads in a C++ multithreaded program? 0:58
  • How does htop improve on top for monitoring C++ multithreaded programs on Linux? 1:56
  • How does the Linux perf tool analyze C++ program performance at kernel level? 2:22
  • How does gprof profile C++ program call graphs and timing on Linux? 1:40
  • How does Intel VTune profile concurrent C++ programs at the hardware level? 3:11
  • What does Google Orbit offer for profiling concurrent C++ software? 2:43
  • What does heaptrack reveal about dynamic allocation in C++ concurrent programs? 1:55
  • How does Valgrind's Helgrind tool detect deadlocks in C++ multithreaded program? 1:28
  • How does lstopo from hwloc package visualize CPU and cache topology in Linux? 3:19
  • How does the pahole utility reveal C++ class memory layout and padding? 1:39
  • How does perf stat reveal false sharing in a C++ concurrent atomic benchmark? 4:07
  • What other profiling tools are worth exploring for C++ concurrency analysis? 2:11
Chương 40 [Advanced Multithreading Design] Lock Free C++ Concurrent Data Structure Design
  • What is wait-free programming in C++ and what does it guarantee? 1:36
  • What is lock-free programming in C++ and how does it differ from wait-free? 1:19
  • What is obstruction-free programming and when is it useful in C++? 2:15
  • Knowledge Check
  • How do ACID transaction principles apply to lock-free programming in C++? 4:39
  • What are the essential guarantees of std::atomic in C++11 for lock-free design? 2:46
  • When are C++ atomic operations lock-free and when do they use internal locks? 4:00
  • Knowledge Check
Chương 41 [Advanced Multithreading Design] Double Check Locking Deep Dive
  • How does double-checked locking implement thread-safe singleton initialization? 1:34
  • How does an atomic pointer implement thread-safe lazy initialization in C++11? 4:36
  • Knowledge Check
  • How do unique_ptr and std::once_flag achieve lazy initialization in C++11? 2:46
  • Why is declaring a static local variable the cleanest thread-safe init in C++? 0:14
  • What are the core requirements when designing concurrent data structures in C++? 3:43
  • Knowledge Check
Chương 42 [Advanced Multithreading] Concurrent Singly Linked List analysis
  • What is the problem statement for a lock-free C++ singly linked list design? 1:29
  • How is a concurrent singly linked list class structured in modern C++? 2:01
  • How are constructor, destructor, and find implemented in a C++ lock-free list? 3:39
  • How does push_front insert a node atomically in a lock-free C++ linked list? 5:09
  • How is pop_front designed for a concurrent C++ lock-free singly linked list? 4:57
  • Knowledge Check
Chương 43 [Advanced Multithreading] ABA problem, RCU, Hazard pointers.
  • What is the ABA problem in concurrent C++ and why is it a lost update? 3:29
  • Solutions for ABA problems in multithreading environments 4:45
  • Why is safe node deletion difficult in C++ concurrent data structures? 4:34
  • Knowledge Check
  • How does shared_ptr in a C++ lock-free linked list node manage object lifetime? 2:35
  • How are find and pop_front implemented with shared_ptr in a C++ linked list? 2:33
  • Concurreny analysis of mulithreading events in the reference class 2:18
  • How does the ABA problem affect a concurrent C++ singly linked list traversal? 1:19
  • Knowledge Check
  • What are the design goals of the Read-Copy-Update (RCU) protocol in C++? 2:28
  • How does RCU enable a thread-safe growable array design in modern C++? 7:17
  • Knowledge Check
  • What are hazard pointers and what problem do they solve in concurrent C++? 6:31
  • What are the design goals for a C++20 thread pool and executor framework? 3:05
  • What concurrent data structures can be built by applying C++ lock-free theory? 1:27
  • Knowledge Check
Chương 44 [Advanced Multhreading] Design Guidelines for using Modern C++ concurreny tools
  • What should you measure before adding multithreading to a C++ application? 0:54
  • Why is concurrent multithreaded software development inherently complex? 2:09
  • Knowledge Check
  • What are the best practices for designing efficient concurrent C++ systems? 2:38
  • What are the key architectural patterns for concurrent C++ program design? 9:07
  • Knowledge Check
Chương 45 [Advanced] Testing and Debugging Challenges with Concurrent Data Structures
  • What are the two main categories of bugs in C++ multithreaded programs? 0:58
  • What are the three categories of blocking-related bugs in C++ multithreading? 0:58
  • What types of race condition bugs appear in C++ concurrent production code? 0:57
  • What code review techniques help find bugs in C++ concurrent multithreaded code? 3:26
  • What challenges make testing concurrent C++ code in production difficult? 4:25
  • How should concurrent C++ code be designed to make it easier to test? 2:01
  • Knowledge Check
  • What testing strategies are effective for concurrent C++ applications? 3:09
  • What third-party libraries and tools improve C++ concurrent testing efficiency? 5:46
  • Knowledge Check
Chương 46 [Beginner] Tools for software engineering with C++ to ship production code
  • What peripheral tools are required to ship C++ code in production? 8:32
  • What are the key C++ compilers and how do they differ in production? 7:39
  • Compiler knowledge check
  • What is CMake and why is it used as a C++ build system in production? 5:16
  • CMake knowledge Check
  • What is Git and why is it essential for C++ software development teams? 3:26
  • Git / VCS knowledge check
  • What do static analysis tools check for in C++ code before execution? 7:14
  • Static Analysis Tools Quiz
  • Introduction to Automated Testing Tools needed to ship robust and correct C++ 9:03
  • Testing Quiz
  • Introduction to Debugging Tools needed to Fix Bugs 11:05
  • Debugging tools knowledge check
  • Introduction to CI/CD tools used for C++ production 11:34
  • CI/CD Knowledge check
  • Introduction to Profiling tools used to improve performance of C++ code 9:06
  • Profiling tools quiz
  • Alternative modes of deploying C++ in production 12:31
  • Deployment Mode knowledge check
  • [INTERMEDIATE] C++ dev environment from scratch and using ChatGPT for learning
Chương 47 [Intermediate/Beginner] Refactoring 101: Basic steps to build robust C++ program
  • What is the reality of working with C++ codebases and refactoring in industry? 6:16
  • What are the basics of refactoring C++98 code patterns toward modern C++? 6:47
  • What refactoring opportunities does modern C++11 provide over legacy code? 2:28
  • What tools make C++ refactoring easier without requiring local setup? 7:12
  • What approaches are used to solve C++ refactoring coding exercises? 2:28
Chương 48 [CODING PRACTICE] [REFACTORING] Coding Exercises to deal with legacy code
  • Moving code to C++11. Refactoring simple codes to Modern C++.
  • Non-Static Data Member Initializers
  • Working with templates
  • Working with templates and multiple types
  • Getting started with functions
  • Working with functions
  • Linked List (Most interview portals still write it incorrectly!)
  • Working with pointers
  • Initializing containers
  • Working with Enums
  • Working with user defined data strcutures : Graph
  • Working with built-in algorithms
  • Working with user defined data structures : HashMaps
  • Deleted functions
  • Bitsets
  • Working with Arrays as a container
  • Using move semantics in modern C++
  • Concurrency features
  • Constructors
  • Using constexpr
  • The user defined conversion functions
  • Attribute specifier squences
  • Using Modern C++ to improve code by testing code snippets in online tools
Chương 49 [CODING PRACTICE] Using STL algorithms and containers in production as default
  • STL Alogrithms Exercise - 1 - Search Operation
  • STL Alogrithms Exercise - 2 - Batch operations
  • [C++17] STL Algorithms Exercise - 3 - Batch Operation
  • [C++20] STL Algorithms Exercise - 4 - Batch Operation
  • [C++11] STL Algorithms Exercise - 5 - Search Operation
  • STL Algorithms Exercise - 6 - Search Operation
  • STL Algorithms Exercise - 7 - Search Operation
  • STL Algorithms Exercise - 8 - Search Operation
  • STL Algorithms Exercise - 9 - Search Operation
  • STL Algorithms Exercise - 10 - Search Operation
  • STL Algorithms Exercise - 11 - Search Operation
  • STL Algorithms Exercise - 12 - Search Operation
  • STL Algorithms Exercise - 13 - Search Operation
  • STL Algorithms Exercise - 14 - Copy Operation
  • STL Algorithms Exercise - 15 - Copy Operation
Chương 50 [CODING PRACTICE] C++17 features coding exercises
  • [C++17] Using Structured Bindings
  • [C++17] if statements with initialization
  • [C++17] switch statements with initialization
  • [C++17] Using inline variables
  • [C++17] Using inline variables with thread_local
  • [C++17] Extended Aggregate Initialization
  • [C++17] nodiscard attribute
  • [C++17] fallthrough attribute
  • [C++17] Nested Namespaces
  • [C++17] Relaxed Enum Initialization from Integral Values
  • [C++17] Fixed Direct List Initialization with auto
  • [C++17] Compile time if statements
  • [C++17] using the string view feature
  • [C++17] Fold expressions
Chương 51 [CODING PRACTICE] C++20 Features coding exercises
  • [C++20] Spaceship operator
  • [C++20] Using ranges with builtin concepts
  • [C++20] Using Views feature with collections
  • [C++20] Borrowed Iterators
  • [C++20] Working with subrange feature
  • [C++20] Working with ref_view feature
  • [C++20] Working with the common_view feature
  • [C++20] Working with generating view feature
  • [C++20] Filtering Views
  • [C++20] Transforming Views
  • [C++20] Mutating Views
  • [C++20] Views for multiple ranges
Chương 52 [CODING PRACTICE] Data Structures and Algorithms: Pseudo code to Production code
  • Collaborate with AI ChatBots of your choice as assistant in these exercises.
  • Breadth First Search Algorithm (BFS)
  • Depth First Search (DFS) Algorithm
  • Quick Sort Algorithm
  • Selection Sort Algorithm
  • Merge Sort Algorithm
  • Count Sort Algorithm
  • Bin or Bucket Sort
  • Radix Sort
  • Shell Sort
  • Bubble Sort
  • Chaining in Hash Tables
  • Prim's Minimum Cost Spanning Tree
  • Kruskal's Minimum Cost Spanning Tree
  • Binary Search Algorithm
  • Working with 2D arrays
  • Fibonacci Series using Recursion (Memoization)
Chương 53 [Capstone Project] Implementation of capstone as coding exercises
  • Step 1 : Logger + CLI Parser
  • Step 2 : CRUD Store
  • Step 3 : Validation Errors
  • Step 4 : repl-batch
  • Step 5 : replace-self-tests
  • Step 6 : Custom Hashtable
  • Step 7 : Benchmark
  • Step 8 : Append log
  • Step 9 : Log replay
  • Step 10 : Snapshot
  • Step 11 : Combined Startup
  • Step 12 : Log Rotation
  • Step 13 : Log Compaction
  • Step 14 : Crash Recovery
  • Step 15 : Serialization
  • Step 16 : Transactions
  • Step 17 : Undo Buffer
  • Step 18 : Mutex
  • Step 19 : rwlock
  • Step 20 : Deadlock
  • Step 21 : Transaction Log
  • Step 22 : Isolation
  • Step 23 : Wire Protocol
  • Step 24 : TCP Server
  • Step 25 : Multi-Client
  • Step 26 : Client Pool
  • Step 27 : Authentication
  • Step 28 : Load Test
  • Step 29 : Configuration
  • Step 30 : Leader Forward
  • Step 31 : Log Shipping
  • Step 32 : Heartbeat
  • Step 33 : Election
  • Step 34 - Ack Toggle
  • Step 35 - Final Integration
  • Step 36 : Crash Recovery
Chương 54 [CODING PRACTICE] Advanced Data Structure and Algorithms (ongoing updates)
  • Guidelines
  • Intrusive Doubly Linked List
  • Listpack Compressed Arrays
  • Quicklist Hybrid Layouts
Chương 55 [For All] Some tips on how to become resourceful C++ programmer.
  • Where is C++ used in industry and what makes it essential for those domains? 3:22
  • How should C++ developers continue learning independently after this course? 3:45
  • What online tools and career perspective should guide a C++ engineer's growth? 8:58

Requirment

  • Basic programming awareness is expected. Examples: Questions like "What is a variable?", "What is a processor?" etc. will NOT be answered in the course.

  • Access to desktop based browser is mandatory to complete the coding exercises and the online compiler too access.

  • Course guides about using online compiler enviroment and hence DOES NOT explain or expect usage of any IDE application.

Outcomes

  • C++ Fundamentals: Grasp the core concepts including variables, data types, arithmetic operations, and basic I/O.

  • Design Your Own Types: Learn the art of defining custom types using classes, structures, unions, and enumerations.

  • Understanding Modularity: Organize and structure your code effectively using namespaces, source files, and headers. Introduction to C++20 Modules feature.

  • Dive into OOP: Get introduced to the world of Object-Oriented Programming in C++ and understand classes, constructors, member functions, and overloading.

  • Understand Essential Operations: Demystify copy and move semantics and lay the foundation for the Rule of Three/Five.

  • Harness the Power of Templates: Delve into generic programming with C++ templates, ensuring type safety without limitations.

  • Concepts (C++20) and Generic Programming: Dive deeper into ensuring type-safety at compile-time through concepts.

  • Explore the C++ Library: Get familiarized with the C++ Standard Library, from containers and algorithms to a multitude of utilities.

  • Strings and Beyond: Master string operations, string_view(C++17) and harness the power of regular expressions.

  • Familiarize with I/O Streams: Navigate the world of I/O streams for efficient and formatted input-output operations.

  • Container Proficiency: Explore powerful container classes such as vector, list, and map.

  • Algorithmic Prowess: Understand the nuances of how algorithms work with containers and iterators.

  • C++ Utilities: Equip yourself with knowledge on smart pointers, time/date utilities, and more.

  • Concurrency & Parallelism: Get started with the concurrent world of C++, learning about threads, tasks, and synchronization mechanisms.

  • 200+ coding exercises and assignments to immediately apply the learned knowledge.

  • Details of C++ memory model on which atomics are built

  • Concepts of memory barriers and memory order in C++

  • Using Modern C++ to design lock free algorithms with C++ atomics and memory model

  • Importance of sequential consistency in concurrency

  • Getting high performane using C++ memory model

  • External factors influencing performance of atomics

  • Tools to use in production while working with C++ in production

Instructor

...
RougeNeuron Academy

0.0

  • ... 0 Student
  • ... 1 Course
  • ... 0 review

View Details

Reviews

Rate this course :

Remove all