Type-Safe Interfaces with Modern C++

Name: Type-Safe Interfaces with Modern C++
Rating: 4.6 (16 reviews)

Master the art of development with Modern C++ type system

Created byPackt Publishing

Last updated 11/2019

English

What you'll learn

Use type system to your advantage
Create safe, rich and expressive interfaces
Use Pattern matching to implement metaprogramming
Real world scenarios to tackle programming tasks

Course content

4 sections • 18 lectures • 2h 17m total length

The Course Overview2:52
This video provides an overview of the entire course.
Understanding Variants5:43
Understand what a “variant” is and its usefulness.
`struct` ? `enum class` ? `variant` progression
Product and sum types
Variants versus unions
std::variant – Basic Interface8:42
Learn about the basic interface of the new C++17 std::variant class.
Learn Construction and solve an assignment
Understand checking an active alternative
Explore accessing an active alternative
std::variant – Visitation8:07
Understand what “visitation” is and how it can be applied to variants.
Learn the definition of visitations
std::visit with struct and generic lambda
Understand the shortcomings of std::visit
std::variant – Use Cases16:57
Learn about realistic use case scenarios where std::variant can be used effectively.
Learn type-safe error handling
Understand state machines
Explore recursive data structures
std::variant – Recap4:29
Section recap.
What a variant represents
std::variant interface and usage
Example of use cases

The Problem with std::visit4:05
Understand why std::visit is not optimal and what pattern matching is.
Learn what patterns matching is
Explore the problems with std::visit
Comparison between std::visit and match
Creating an Overload Set10:07
Write a generic class that creates an overload set from scratch.
Implementation overview of match
Build an overload set
C++17 deduction guide
Match – Implementation5:11
Understand what “visitation” is and how it can be applied to variants.
Structure of the match function
Learn implementation of match function
Usage example and generated assembly benchmark
Match – Recap5:11
Section recap.
Std::visit versus match
Overload set
Match implementation

What Is an Optional?9:17
Learn about the concept of “optional value” and why it is useful
Learn the meaning of `optional<T>`
Memory layout of `optional<T>`
Optional versus pointers
std::optional – Basic Interface9:15
Get familiar with the interface provided by std::optional.
Learn construction and solve an assignment
Access to stored value
Reset and emplace
std::optional – Use Cases8:20
Understand realistic use cases for optional, by looking at example function interfaces and data structure definitions
Understand when to use std::optional
Modeling simple failure states or value absence
Section recap

std::string8:17
Learn about the idea of an “owning wrapper” by understanding how `std::string` works internally and what its semantics are.
Reminder of what `std::string` is
How `std::string` works and its semantics
`std::string` in interfaces
std::string_view – Introduction5:35
Learn about `std::string_view`, introduced in C++17.
Concept of a “string view”
Semantics of `std::string_view`
Interoperability with `std::string`
std::string_view – Basic Interface12:22
Learn about the most important member functions and operations provided with `std::string_view`.
Learn construction and solve an assignment
Container interface and shrinking operations
Comparisons
std::string_view in Interfaces6:13
Understand when and why to use `std::string_view` as part of function interfaces, and the performance benefits it brings.
`string_view`: intention of “observing”
Retain strings passed to functions
Performance comparison with `std::string`
Other Examples of Owning/View Classes6:30
Find a pattern similar to `std::string`/`std::string_view` in other classes, and understand the importance of having both owning/non-owning wrappers.
Smart pointers, raw pointers, and references
Function objects
Contiguous sequences

Requirements

C++, C++11/14 and master Modern C++17 utilities and techniques

Description

In this course we’ll learn how to write correct, safe, and performant code by making use of C++’s type system. Firstly, we’ll learn about the Standard Library’s “algebraic data types” and how they can increase safety, performance, and readability of your application/library. We’ll then look at function interfaces. As an example, writing a function that takes a string in such a way that it performs optimally with both std::string and const char* seems like a daunting task. It gets even more tricky with functions taking other functions as input. Is it possible to generalize these issues and provide the “perfect” interface?

About the Author :

Vittorio Romeo is a Software Engineer at Bloomberg LP. He completed his Bachelor's degree in Computer Science at "Università degli Studi di Messina".

He began programming at a very young age and is now a C++ enthusiast. While following the evolution of the C++ standard and embracing the newest features, he worked on several open-source projects, including modern general-purpose libraries and free cross-platform games.

Vittorio is an active member of the C++ community: he participated as a speaker at CppCon 2014/2015/2016, ++it Florence 2015 and at his local Linux Day 2013/2014 events, as a Student/Volunteer at C++Now 2015/2016, at Meeting C++ 2015/2016.

He currently maintains a C++-related blog and a YouTube channel featuring well-received modern C++11 and C++14 tutorials.

When he's not writing code, Vittorio enjoys weightlifting and fitness-related activities, competitive/challenging computer gaming and good sci-fi movies/TV-series.

Who this course is for:

Intermediate C++ developers familiar with C++11/14 aiming to discover and master Modern C++17 utilities and techniques.

Type-Safe Interfaces with Modern C++

What you'll learn

Explore related topics

Course content

Variants6 lectures • 47min

Implementing Variant Pattern Matching4 lectures • 25min

Optionals3 lectures • 27min

Function Parameters and Ownership5 lectures • 39min

Requirements

Description

Who this course is for: