Register your product to gain access to bonus material or receive a coupon.
C++20 Fundamentals LiveLessons Part V (Video Course)
- By Paul Deitel
- Published Dec 10, 2024 by Pearson.
Online Video
- Your Price: $279.99
- List Price: $349.99
- About this video
Video accessible from your Account page after purchase.
Description
- Copyright 2024
- Edition: 1st
- Online Video
- ISBN-10: 0-13-769486-5
- ISBN-13: 978-0-13-769486-0
The professional programmer's Deitel® video guide to Modern C++ -- C++20, C++17, C++14 and C++11 -- with a look toward C++23 and C++26.
Overview:
C++20 Fundamentals with Paul Deitel is a code-intensive presentation of C++, the world's most popular language for building high-performance business-critical and mission-critical computing systems.
Related Learning:
- Live Training: Modern C++ Full Throttle with Paul Deitel: Intro to C++20 & the Standard Library by Paul Deitel -- Presentation-Only Intro to Fundamentals, Arrays, Vectors, Pointers, OOP, Ranges, Views, Functional Programming; Brief Intro to Concepts, Modules & Coroutines
https://learning.oreilly.com/search/?q=Modern%20C%2B%2B%20Full%20Throttle%20with%20Paul%20Deitel%20paul%20deitel&type=live-event-series&publishers=Pearson - Live Training: C++20 "Big Four" Full Throttle with Paul Deitel: Ranges, Concepts, Modules, Coroutines & More with Key C++ 23 Features -- In-Depth, Presentation-Only Treatment of the "Big Four," plus Containers, Iterators, Algorithms, Views, Functional Programming, Templates, Metaprogramming, Concurrency
Intended for programmers with a background in another high-level language, in this video course, you'll learn Modern C++ development hands-on using C++20 and its "Big Four" features--Ranges, Concepts, Modules and Coroutines. In the context of 200+ hands-on, real-world, Deitel live-code examples, you'll quickly master Modern C++ coding idioms using popular compilers--Microsoft Visual C++®, GNU® g++ and LLVM®/Clang clang++.
After the C++ fundamentals quick start, you'll move on to C++ standard library containers array and vector; functional-style programming with C++20 Ranges and Views; strings, files and regular expressions; object-oriented programming with classes, inheritance, runtime polymorphism and static polymorphism; operator overloading, copy/move semantics, RAII and smart pointers; exceptions; standard library containers, iterators and algorithms; templates, C++20 Concepts and metaprogramming; C++20 Modules and large-scale development; and concurrency, parallelism, the C++17 and C++20 parallel standard library algorithms and C++20 Coroutines.
NOTE: This video course is one in a series of five:
- C++20 Fundamentals LiveLessons Part I
- C++20 Fundamentals LiveLessons Part II
- C++20 Fundamentals LiveLessons, Part III
- C++20 Fundamentals LiveLessons Part IV
- C++20 Fundamentals LiveLessons Part V
Download the C++20 Fundamentals source code from Paul's GitHub repository at https://github.com/pdeitel/CPlusPlus20FundamentalsLiveLessons. This repository will be updated with the additional lessons' examples as the lessons are completed.
About the Instructor:
Paul J. Deitel, CEO and Chief Technical Officer of Deitel & Associates, Inc., is an MIT graduate with 43 years in computing. Paul is one of the world's most experienced programming-languages trainers, having taught professional courses to software developers at all levels since 1992. He has delivered hundreds of programming courses to industry clients internationally, including SLB (formerly Schlumberger), Cisco, IBM, Siemens, Sun Microsystems (now Oracle), Dell, Fidelity, NASA at the Kennedy Space Center, the National Severe Storm Laboratory, White Sands Missile Range, Rogue Wave Software, Boeing, Puma, iRobot, UCLA Anderson's Master of Science in Business Analytics (MSBA) and Master of Financial Engineering (MFE) programs, and many more. He is among the world's best-selling programming-language textbook, professional book, video and interactive multimedia authors.
Skill Level:
- Beginner to Intermediate
What you will learn in Part V (of five parts):
- Lesson 16 -- C++20 Modules: Large-Scale Development -- Introduction to C++20 modules; motivations for modularity; encapsulation with modules; importing standard library headers as header units; primary interface units; exporting declarations from a module; importing modules to use their exported declarations; separating a module's interface from its implementation; module partitions; submodules; visibility vs. reachability of declarations; and how modules can reduce translation unit sizes and compilation times.
- Lesson 17 -- Parallel Algorithms and Concurrency: A High-Level View -- Standard library parallel algorithms; profiling sequential vs. parallel; execution policies; multithreaded programming; thread states & thread life cycle; launching tasks with std::jthread; producerconsumer relationship; synchronizing access to shared mutable data; mutexes, locks & condition variables; minimizing waits with a circular buffer; cooperatively canceling jthreads; launching tasks with std::async; thread-safe initialization; intro to atomics; coordinating threads with C++20 latches, barriers & semaphores.
- Lesson 18 -- C++20 Coroutines -- What coroutines are and how they're used; co_yield to suspend a generator coroutine and return a result; co_await operator to suspend a coroutine while it waits for a result to become available; co_return to terminate a coroutine and return its result (or control) to its caller; open-source generator library for creating a generator coroutine with co_yield; open-source concurrencpp library for creating coroutines with co_await and co_return.
- Lesson 19 -- Stream I/O & C++20 Text formatting -- Understand legacy object-oriented stream I/O; character I/O; high-performance unformatted I/O; stream manipulators for octal and hexadecimal integer formats; scientific and fixed-point floating-point formatting; managing format state; alignment and padding; determine success or failure of I/O operations; tie output streams to input streams; and C++20's concise and convenient text-formatting capabilities (presentation types, positional arguments, alignment, numeric formatting, field widths & precisions).
- Lesson 20 -- Other Topics -- Runtime type information (RTTI); inheriting base-class constructors; runtime polymorphism techniques; multiple inheritance; storage classes and storage duration; mutable members in const objects; namespaces; operator keywords; managing shared dynamically allocated objects; determining compile-time types with decltype; [[nodiscard]]; and an intro to several C++23 features.
About Pearson Video Training:
Pearson publishes expert-led video tutorials covering a wide selection of technology topics designed to teach you the skills you need to succeed. These professional and personal technology videos feature world-leading author instructors published by your trusted technology brands: Addison-Wesley, Cisco Press, Pearson IT Certification, Sams, and Que Topics include: IT Certification, Network Security, Cisco Technology, Programming, Web Development, Mobile Development, and more. Learn more about Pearson Video training at http://www.informit.com/video.
Video Lessons are available for download for offline viewing within the streaming format. Look for the green arrow in each lesson.