CppCon 2019: Better code: relationships

Sean Parent

  • Let’s rotate (cppcon six years ago); meme?
  • – Goal: No contradictions
  • A novice sees only the chessman; an amateur sees the board; a master sees the game

Entity notation

  • Witnessed Relationships: a relationship represented by an object
    • copyable and equality comparable
  • When an object is copied or moved any witnessed relationship is either maintained, severed, or invalidated
  • When an object is destructed any witnessed relationship is either severed, or invalidated


  • std::move()

    is an unsafe operation


  • One new feature: concepts (joke about contracts)
  • Hoare Logic (paper from 1969, C.A.R Hoare)


Applying “Design by Contract”


  • Preconditions (require)
  • Postconditions
  • Invariants


A compile time constraint to select an appropriate operation

Contracts assert at runtime if an an operations

A runtime constraint to select an appropriate operation is know a pattern matching

No Raw Loops

The Game

  • Architecture is the art and practice of designing and constructing structures

Timer example


Container support these:

  • Add an object and obtain receipt
  • Use receipt to retrieve the object
  • iterate

Russian Coat Check Algorithm

  • Receipts are ordered
    • Coats always appended with stub
    • Binary search to retrieve coat
      • when more than half the slot are empty; compact the coats
  • Coats are always ordered receipt stubs
  • Coats ordered by insertion

Double entry bookkeeping

  • Every transaction twice
  • 5 standard accounts: Asses, Capital, Liabilities, Revenues, and Expenses
  • This ensure the mechanical process of entering a transaction is done in two ways


  • unit tests expose contradictions

No Raw Synchronization Primitives

Use strong preconditions to move the issue to the caller

Setting a property

  • Code is redundant
  • – Different aspects of the same code
    • value is a*b when a changes
    • other_value is a*b when b changes
    • asking for troubles
  • Different, mutually exclusive relationships with non-local control
  • Implied last in wins relationship
  • An incidental algorithm; property convert to the correct value
  • property is not a simple property but a stream, trigger, or latch
  • or it’s just wrong

No Raw Pointers for talks


CppCon 2019: Time Travel: Gradual Typing in C++

Hyrum Wright

C++ is a dynamically typed language

example with sso_string and union

If somebody can (ab)use your API, they will

Types Encode constraints

int timeout;
int number_of_pumpkins = 6*timeout;


void set_deadline (absl::Duration deadline);

See “Time Programming Funamentals” by Greg Miller

Abseil Time API

  • Valid invalid operations: Duration + Duration gives Duration;
Duration + Time gives Time;
Time + Time is invalid, etc

Gradual Typing

  • python: adds annotation


  • Automated (almost) everything
  • Keep code buildable (each multiple steps)
  • Keep code readable
  • Eventually converge at a fixed point

Things that don’t work

  • Monolithic changes
  • Variable type
    • Most integers don’t represent time
  • Variable name
    • What does timeout_seconds actually mean?
  • Comments super unreliable

Types of transformations

  • Expression
    • Simplification
    • Comparison
    • Addition and Subtraction
    • Distribution
  • Variable
    • Local, global, class members
  • Inter-function
    • Parame and value

Expression: Simplification

  • Makes matching easier
  • clang-tidy code for matcher
  • code for fixer

Expresion: Comparison

Inter-function return values

Seeding Type Information

  • Identify high value targets


  • You added a bug … oh
  • Thanks
  • (crickets)

Other applications

  • Converting to std::string_view
  • Ownership deduction (i.e. std::unique_ptr)


  • How to justify? “We should be able to change our software”

CppCon 2019: CppChat Live

John Kalb, Andrei; Herb Sutter; Phil Nash

Talking about giving a presentation

  • Recommending session
  • Giving a talk is a performance.
  • Andrei: treats each talk as different at different event. Re-does slides

Review of Andrei’s keynote

  • sort()

    algorithm needs to make many decision: attributes need to be introspected/reflect. E.g. cost of comparison; cost of move; etc

  • metaclasses are an example of this (Herb Sutter).
  • “Modules help with new features? e.g. exceptions”
  • “The dawn of a new error” by Phil Nash
  • Swift assumes out of memory is not recoverable. “C++ aspires to handle out-of-memory”
  • Looking at error handling is a great way to evaluate a language
  • Andrei:

    is a fundamental building block just like


CppCon 2019:From STL to Ranges

Jeff Garland


  • The beginning of the end – for begin and end


std::sort(a.begin(), a.end())



Example with find_if

the ranges way: filter_view

for (int i : rng::filter_view (a, is_six)) { std::cout << i << “ “; }

Tristan Brindel NanoRange


  • supports several
  • range: something that can be iterator over
  • range algo: algorithm that takes range
  • view: lazy range thats cheap top copy
  • ranger adapter: turn range into a view


  • 3 new names ranges, ranges::views, views = ranges::views

Why new namespaces

  • behavior and guaranteed of some algorithms are changed

What’s a range

  • iterator pair is simplest
  • sentinel and iterator can be different types
  • ranges can be infinite
  • any container with begin()/end() can be used in a range

Views are ranged with lazy evaluation

  • non-owning of elements
  • all methods

    for copy and assignment

range adaptors -> views from ranges

  • pipeline syntax

filter_view adaptor

for (int i = range_filter_view (vi, is_event))

No more for loops

Range Algorithm details

  • list of range algorithms

Projection parameters

  • provides first class filtering predicate
  • comes from the Adobe Source Libraries (ASL)

ranges::sort(vistuff, std::less<>{}, [](auto const &i) {return i.value;})

Views and View Adaptor details

How do ranges perform

  • Compile time: no noticeable difference
  • runtime: nothing expected over stl algorithms



CppCon 2019:Dawn of a new Error

Phil Nash


P0709 R2 Zero-overhead deterministic exceptions (static exceptions)

Swift has best error handler

Exploding return types

p03w3R7 std::expected

p0798R4 Monadic operations for std::optional

What is std::error


error code always represent an error

p1029R1 [[move relocates]

p1144 object relocation in terms of move plus destroy

With compiler optimizations no extra overhead compared to regular return

error_code fits in two registers

auto result = try add_one (divide (42, parse_int(input));



  • What is


Fun · Technology

CppCon 2019: Some photos

CppCon moved to Denver, Colorado (technically Aurora, CO) just a few miles from Denver Airport. 1400 people attended from Sept 16-20 and a 150 talks over the 5 days. Additionally, there were 1 and 2 day training classes the weekends before and after the conference.

The Gaylord Rocky Mountain Resort hosted CppCon. It’s a huge place that’s very conference oriented though there are some nice pools and rec areas. You are pretty isolated so plan on eating at the nice but overpriced restaurants.


CppCon 2019: Getting Allocators out of Our Way

Alisdair Meredith and Pablo Halpern

Allocators are great

std::pmr::monotoic_buffer_resource src(buffer, sizeof (buffer);
pmr::set. uniq(&src);

What if we could reduce the cost

goal: reduce cost of developign an allocator aware

What’s our problem?

Allocators bloat class interfaces

Performance in practice

  • Memory hiearchy: Cache; main, virtual
  • objects used together should be together

C++ allocatros

allocator_traits simplify allocators; mostly for users. Containers now have problems in their face

What about nested containers

  • In a vector<string> vector has one and each string potentiallly different allocator
  • scoped allocator model: container passes allocator into each item. Solves memory diffisuion
  • scoped_allocator_adapter
  • Allocator template policies interfere with vocabulary types

C++17: PMR: a simpler allocator model

  • Non-template std::pmr::memoryresource
  • The wrapper
  • class memory_resource
  • polomorphic_allocator
  • polymorphic_allocator<byte>
    • “One true” allocator vocabulary type
    • Only a template to be compatible for C++11
  • std::pmr::new_delete_resource()
    • Uses new/delete
    • always availabel
    • thread safe
  • unsynchronized_pool_resource
    • Pools of similar sized objects
    • good for dynamic data strucures
    • Single-threaded
    • avoids concurrency lock overhead
  • monootonic_buffer_resource
    • Ultra fast; single threaded, contiguous
    • for containers that grow monotonically
  • test resource
    • GitHub bloomberg/p1160

How to use allocators

class Student {
  pmr::string d_name;
pmr::string d_email
pmr::vector<int d_grades;

using allocator_type = pmr::polymovic_allocator<>; // Important


  • Overload each constructor having default_arguments
  • Variadic argument lists: allocator goes at the beginning

Rewriting std::unordered_map to use pmr allocators

  • Example with copying constructors. Lots of duplicated code

What about a language solution

  • Build on a strong foundation built up to C++17

HashMap<int,int> x {} using myAllocator;

  • using myAllocator


  • Bloomberg vision 2020

CppCon 2019: Converting to C++20 Modules

Nathan Sidwell


g++ -fmodules-ts <a href=""></a>

  • Using timyxml2 library as example
  • On header, one .cpp, one makefile, one test program
  • When you compile a module you get a compiled module interface (CMI)
  • CME filenames related to module names is implementation defined as is where they are placed

A header unit

  • step through telling bild system: mapping file with rules for .h.gcm

CppCon 2019: Maintainability and Refactoring Impact of Higher-Level Design Features

Titus Winter

Multi-step refactoring

  • Basic atoms of refactoring

Rename a type

namespace oldns {class StringPiece ...}
namespace absl {class string_view ...copy StringPiece }


namespace oldns {using StringPiece = absl::string_view}

break with forward declaration. forward declarations no real performance improement

also, ADL causes it to break


namespace oldns {class StringPiece...}
namespace absl { using string_view = oldns::StringPiece;}

then deal with ADL problems

Find a way tso pre/post syntax/semancs can co-exist

Can we change functions?

  • small atoms: weaken preconditions; stregthen postconditions
  • large atomes: opposite

Changing return types

  • void to anything is doable
  • into to int64_t?

Can we change templates

Can we change concepts

  • Single-step: sure
  • Multi-step: No

CppCon 2019: Speed Is Found In The Minds of People

Andrei Alexandrescu

This was the best talk I saw at CppCon 2019


  • What is quick-select?

Naive Implementations

  • qsort()


  • qsort() with fallback to small_sort()

Investigating small_sort

  • Challenge: increase the THRESHOLD so sorting for 1000 elements work
  • binary search is slower. Branch prediction is reader
  • branchless even slower than binary
  • middle-out insertion support: better comparison and better moves (13%) but no performance change
  • stupid_small_sort(): make_heap(); insertion_sort(). Improvment in comparison, swaps; 9% slower
  • Blended cost: (C(N) + M(n) + k(D(n))/n. (compares + swaps + distance)


  • 1990’s OOP
    • Inheritance and virtuals
  • 2000’s Generic Programing
    • Iterators and algos
  • 2020’s: design by introspection
    • Inspect and customize everything
    • We can’t implement the best sort with generic programming


  • Parametric complexity theory???