C++ Templates for Developers

As an intermediate-level C++ programmer, you already know about and have very likely used one or more kinds of C++ templates in your code. Whether you've applied std::vector or std::array to your work, or called upon any of the multitude of algorithms that the standard library provides, you've experienced some of the power that templates add to a C++ programmer's toolkit.

This Workshop will help you take your knowledge and experience to the next level, so that you will both (1) understand exactly how C++ templates are handled by a compiler, and (2) be able to take advantage of that knowledge to create templates that are tailored to your own programming needs.

In this Workshop, we will explore all significant facets of the many kinds of C++ templates (and other templated entities), and will do so in as much depth as our time together will permit. The Workshop will include presentations as well as optional (but recommended) practice exercises, together with numerous examples and tips that you can learn from and apply. Many of our examples and exercises will be taken from the standard library, thus doubling the useful information you'll glean from your participation.

Come discover how the world of C++ templates will open to you once you've mastered a modest handful of straightforward, key insights and principles. Whether it's programming generically, or with variadics, SFINAE, concepts, overloading, or other coding practices, this Workshop will allow you to explore and apply template-based techniques that will help solve problems in your programming domain!

Contents

We will emphasize principles that will allow you to reason about template technology. To that end, the Workshop expects to cover the following representative topics in the time available (not in the order listed here):

Kinds of templates: • alias templates • class templates • concepts • deduction guides • function templates • generic lambdas • templated members • variable templates

Template processing and mechanics: • declaration synthesis • dependent and non-dependent names • function objects • non-deduced contexts • overloading • reference collapsing • specialization (implicit, explicit, partial) • substitution / substitution failure (SFINAE) • template arguments / argument deduction / default arguments • template instantiation and its control • template parameters (type, nontype, and template) • two-phase name lookup

Related C++ language features: • constraints / requires-clauses • declval • enable_if • if constexpr • requires-expressions • sizeof... • static_assert • variadic templates / parameter packs / pack expansion / fold expressions

Related standard library facilities: • constants as types • function and friends • invoke and friends • traits for inspecting types • traits for manipulating types

Classical techniques / practices / idioms: • algorithms • containers • perfect forwarding • tag dispatch • template metaprogramming • void_t and the detection idiom

Prerequisites

Attendees should have good intermediate-level C++ knowledge with at least one to two years of recent C++ coding experience.

Those planning to do the recommended exercises should bring their preferred development environment. A compiler that supports C++20 (e.g., GCC12+) is recommended, but C++17 support can suffice for this Workshop.

Recognition

Past participants in this Workshop have reported their experiences with such praise as:

• "I appreciated that your class laid the solid foundation and built upon that in a deliberate way that enhanced my grasp of the material."
• "It was a fantastic course, and I am saying this as someone who paid for it out of his own pocket."
• "I definitely learned a lot that I'll be able to carry forward into my work. I've also already recommended the course to my colleagues and hope that they'll be able to attend a future iteration."

Dr. Brown looks forward to welcoming you to his "C++ Templates for Developers" Workshop!