CppCon 2024

Unit Testing is a big, complicated subject. With good advice coming in from books, conference talks, and blog posts beyond count, it's a daunting topic even for experienced developers.  Can we make the subject more approachable?

Yes we can.  If we look a little deeper, there are some fundamental principles behind the advice. Further, these principles seem to belong to a small number of "domains", each addressing a very different aspect of unit testing and software development.

For example, "Test error conditions separately", "Tests should be easy to read", and "Write the unit tests first" are all great advice, but each is aiming for a very different goal.

In this talk, we'll survey these domains of unit testing practice, identify some of the basic practices involved in each, and put the larger discussion of unit testing into a more useful context.  We will also see how some unit testing practices enhance or conflict with others, and how these controversies reveal deep philosophical questions that have real consequences for how we go about the day-to-day activity of testing our code.

Are you a fresh face in the world of C++ development, or perhaps you've got a bit of experience under your belt? Have you ever stopped to marvel at just how often std::vector pops up? It's a thing of beauty, a structure you can just keep piling data into, effortlessly sort, search, insert, and delete from. But do you know the price you pay for all this convenience? What about when you need to expand the structure? Or when you're on the hunt for something specific? Ever dabbled with custom predicates to dynamically tweak your data? With a plethora of data structures at our disposal in the standard library, it's a head-scratcher why std::vector seems to steal the show.

Join this talk to unravel the mystery behind why we almost always opt for std::vector, and learn how to wield it with maximum efficiency.

When a C++ compiler encounters an expression like f(x, y), it must consider several language mechanisms to decide which function f the program will call. These mechanisms include name lookup, overload resolution, default function arguments, and template processing. Having a firm understanding of these mechanisms and how they interact will help you write user-friendly interfaces for you and your team.

This session begins by reviewing each of these mechanisms individually. It then examines how those mechanisms interact, focusing on situations that are most likely to occur in practice. Some of the questions that we’ll consider are:

 
• How does the compiler resolve calls on overloaded functions with implicit conversions on multiple arguments?

 
• Why does the compiler apply implicit conversions when resolving calls to overloaded functions, but not when making calls to function templates?>/li>
  

After this session, you’ll have a clearer understanding of how the compiler makes sense out of your code. With this knowledge, you’ll find it easier to craft interfaces that are easy to use correctly and hard to use incorrectly. You’ll also be better able to steer the compiler in your intended direction when necessary.

Your code is not working -- PANIC! Well, not quite! In this session we are going to show you how to write tests to uncover bugs in the first place (and to guard against regressions when they’re fixed) and how to identify the bugs’ root causes with a debugger. These two fundamental software engineering skills (debugging and testing) in combination helps us write better software by improving our confidence that bugs do not reappear -- especially as software scales and changes over time. Debugging and testing are two related skillsets, and in this talk we will provide an introduction and concrete tools showing by example how to utilize each skill together. If you have never used a debugger and think ‘if it compiles it must work’ then this is the talk for you.

In the world of C++, efficient string handling is crucial for performance-critical applications. Enter string_view, a lightweight view into character sequences. In this talk, we’ll explore the fundamentals of string_view, its advantages over traditional string, how it compares to std::span, common pitfalls to avoid, and practical case studies for using it effectively. Whether you’re a beginner or an intermediate developer, join us to enhance your code’s performance and adopt better practices.

Generic programming, better known in C++ as templates, can feel daunting and overwhelming to those unfamiliar with the paradigm.  This Back to Basics talk will explain the foundations of C++ templates, covering the language rules that must be understood in order to work with template code effectively.  I will provide some guidelines for how to use templates and how to write templates.

While you won't come away from this being an expert in template metaprogramming--that's an impossible task for any hour-long presentation--you should have a strong enough foundation that you can correctly maintain template code while you develop your expertise in generic programming over time.

This talk is designed for those who are learning C++ and want an introduction to templates and generic programming.  It will also be useful for experienced C++ developers who haven't mastered templates yet and want to brush up on their understanding of how templates work.

Concepts are a pretty new key feature of C++. Introduced with C++20, they provide a way to deal with requirements and specify constraints on generic code. This can be used to improve overload resolution, avoid invalid use of generic code, improve error handling, and improve documentation of generic code.

In this talk we introduce the basics of concepts. You will get an overview of
- the difference between requirements, concepts, and constraints
- where you can apply concepts
- how to formulate concepts
- what the standard library gives you as and for concepts
- how to design concepts right

Functional programming is a declarative way of writing programs by composing functions.
In many situations, this can lead to code that is easier to write and understand and less error-prone.
However, it requires a shift to a more functional mindset.
This talk gives an introduction to functional programming in C++ using the modern standard library.
We will cover algorithms using `std::ranges`, composable error handling with `std::optional` and `std::expected`, algebraic data types, and separating IO from computation.
In the end, we'll even cover the M-word.

Lifetime management in C++ is flexible and powerful. But this comes with complexity and lots of ways to shoot your leg off. That has only gotten worse as the language has evolved.

This talk introduces or recaps the so-called Rule of 0 and Rule of 5, which suggest that you should aim to need no Special Member Functions (customs constructors, destructors assignment operators) for most of your types. But if you do need them, you probably need all 5.

But if we do need to implement them it can still be hard to know what to do. It helps to know what sort of type you are dealing with, so we’ll break down the common categories.

Along the way we’ll look at vocabulary types we already have in the C++ standard library that can help us move more of our code into the realm of the Rule of 0.

Come with us on a journey through these rules, type categories and behaviours and start to make sense of lifetimes in modern C++.

When delving into Object-Oriented Programming (OOP) in C++, we encounter several pivotal decisions. Questions arise: which data members should be private, public, or protected? Should we solely inherit from a class, or is there a need to modify the base class behavior? And when do we necessitate a virtual destructor? Moreover, are there scenarios where certain member functions cannot be virtual?

Understanding the concept of a virtual member function is crucial as it allows polymorphic behavior. Delving deeper, one might wonder about the compiler's implementation of this mechanism.

Integrating virtual functions with other features, like default parameters, demands careful consideration. This talk will explain why that's the case.

Oh, and by the way, the classic question is, what is the difference between struct and class? Come to my talk to get answers to all these questions.

By the end of this talk, you will depart with a lucid comprehension of OOP subtleties in C++, along with an acute awareness of potential pitfalls.

Rvalue references and move semantics, introduced in C++11, were an important addition for the way we manage resources and optimize performance in our code.
However, mastering these concepts can be challenging, leading to common pitfalls and misunderstandings.

In this session, we will demystify rvalue references and move semantics, covering their underlying principles, practical applications, and best practices. We will start with the fundamentals of what rvalues are, how to implement and use move semantics correctly, covering the delicate syntax rules, then discuss design considerations and guidelines. We will cover the rule-of-zero, rule-of-three and rule-of-five, the need for std::move and when to use it, as well as forwarding references and std::forward.

By focusing on the applicability of the subject, and with a clear and concise exploration of the fine details, participants would gain a solid understanding of how to master rvalue references and move semantics in their own codebase, with the ability to write more efficient and robust C++ code.