2011

• 2011-09 Issues Found Implementing C++0x (with S. Hunt, S. Redl, D. Majnemer) N3307
• 2011-09 constexpr consternation (with D. Gregor) N3308

2012

• 2012-09 Relaxing constraints on constexpr functions / constexpr member functions and implicit const N3444 N3598 N3597 N3652

2013

• 2013-03 Literal operator templates for strings N3599
• 2013-04 Member initializers and aggregates (with V. Voutilainen) N3653
• 2013-04 Clarifying Memory Allocation (with L. Crowl, C. Carruth) N3664
• 2013-09 Single-Quotation-Mark as a Digit Separator (with L. Crowl, J. Snyder, D. Vandevoorde) N3781

2014

• 2014-05 Removing trigraphs??! N3981 N4086
• 2014-05 Exploring classes of runtime size (with J. Snyder) N4025
• 2014-05 Allow typename in a template template parameter N4051
• 2014-10 Attributes for namespaces and enumerators N4196 N4266
• 2014-10 Adding u8 character literals N4197 N4267
• 2014-10 Allow constant evaluation for all non-type template arguments N4198 N4268
• 2014-10 Folding Expressions (with Andrew Sutton) N4191 N4295
• 2014-11 Pointer Safety and Placement New (with Hubert Tong) N4303

2015

• 2015-04 Inline Variables (with Hal Finkel) N4424 P0386R0 P0386R2
• 2015-04 Rewording inheriting constructors (core issue 1941 et al) N4429 P0136R0 P0136R1
• 2015-04 Core Issue 1776: Replacement of class objects containing reference members N4430 P0137R0 P0137R1
• 2015-05 Feature-testing preprocessor predicates for C++17 (with Clark Nelson) N4535
• 2015-09 Introducing a name for brace-or-equal-initializers for non-static data members P0134R0
• 2015-09 Template argument deduction for class templates (Rev. 7) (with Mike Spertus, Faisal Vali) P0091R0 P0091R1 P0091R2 P0091R3 P0091R4
• 2015-09 guaranteed copy elision through simplified value categories P0135R0 P0135R1

2016

• 2016-02 Proposed modules changes from implementation and deployment experience (with Chandler Carruth, David Jones) P0273R0 P0273R1
• 2016-02 Synopses for the C library (with Thomas Koeppe) P0175R0 P0175R1
• 2016-02 std::direct_init<T> for plugging the metaprogramming constructor hole (with Tony Van Eerd, David Sankel) P0271R0
• 2016-03 Coroutines: Language and Implementation Impact (with Daveed Vandevoorde, Geoffrey Romer, Gor Nishanov, Nathan Sidwell, Iain Sandoe, Lewis Baker) P0057R3 P1492R0
• 2016-05 Designated Initialization (with Tim Shen) P0329R0 P0329R1 P0329R2 P0329R3 P0329R4
• 2016-11 Pack expansions in using-declarations (with Robert Haberlach) P0195R2
• 2016-11 Class Template Argument Deduction Assorted NB resolution and issues (with Mike Spertus, Faisal Vali) P0512R0
• 2016-11 Wording changes for proposed Modules TS extensions P0529R0

2017

• 2017-02 Concepts TS revisited (with James Dennett) P0587R0
• 2017-02 Simplifying implicit lambda capture P0588R0 P0588R1
• 2017-06 Unified concept definition syntax (with Andrew Sutton) P0716R0
• 2017-06 Semantic constraint matching for concepts (with Andrew Sutton) P0717R0 P0717R1
• 2017-06 Efficient sized delete for variable sized classes (with Andrew Hunter) P0722R0 P0722R1 P0722R2 P0722R3
• 2017-10 More constexpr containers (with Daveed Vandevoorde, Peter Dimov, Louis Dionne, Nina Ranns, Daveed Vandevoorde) P0784R0 P0784R1 P0784R3 P0784R2 P0784R4 P0784R5 P0784R6 P0784R7
• 2017-10 Implicit creation of objects for low-level object manipulation (with Ville Voutilainen) P0593R1 P0593R2 P0593R3 P0593R4 P0593R5 P0593R6
• 2017-10 Recursive Lambdas P0839R0
• 2017-10 Language support for empty objects P0840R0 P0840R1 P0840R2
• 2017-11 Core Issue 1581: When are constexpr member functions defined? P0859R0

2018

• 2018-01 Symmetry for spaceship (with Tomasz Kamiński, Herb Sutter) P0905R0 P0905R1
• 2018-02 Generalizing alias declarations P0945R0
• 2018-02 Towards consistency between <=> and other comparison operators P0946R0
• 2018-02 Bind Returned/Initialized Objects to the Lifetime of Parameters (with Nicolai Josuttis) P0936R0
• 2018-02 Another take on Modules P0947R0 P0947R1
• 2018-03 Comparison of Modules Proposals (with David Jones) P0986R0
• 2018-03 Halo: coroutine Heap Allocation eLision Optimization: the joint response (with Gor Nishanov) P0981R0
• 2018-04 Plan of Record for Making C++ Modules Available in C++ Standards (with Gabriel Dos Reis) P0983R0
• 2018-05 std::is_constant_evaluated (with Andrew Sutton, Daveed Vandevoorde) P0595R1 P0595R2
• 2018-05 Immediate functions (with Andrew Sutton, Daveed Vandevoorde) P1073R0 P1073R1 P1073R2 P1073R3
• 2018-05 Prohibit aggregates with user-declared constructors (with Timur Doumler, Arthur O’Dwyer, Howard E. Hinnant, Nicolai Josuttis) P1008R0 P1008R1
• 2018-05 Modules for Standard C++ (with Gabriel Dos Reis) P1087R0
• 2018-06 Consistency improvements for <=> and other comparison operators P1120R0
• 2018-06 Merging Modules P1103R0 P1103R1 P1103R2 P1103R3
• 2018-09 Response to P1156 P1180R0
• 2018-10 Modular main() (with Boris Kolpackov) P1203R0
• 2018-10 Contra CWG DR1778 P1286R0 P1286R1 P1286R2
• 2018-10 Filling holes in Class Template Argument Deduction (with Mike Spertus, Timur Doumler) P1021R1 P1021R2 P1021R3 P1021R4 P1021R5 P1021R6
• 2018-10 Implicit Module Partition Lookup (with Isabella Muerte) P1302R0 P1302R1
• 2018-11 Allowing dynamic_cast, polymorphic typeid in Constant Expressions (with Peter Dimov, Vassil Vassilev) P1327R1
• 2018-11 Yet another approach for constrained declarations (with Ville Voutilainen, Thomas Köppe, Andrew Sutton, Herb Sutter, Gabriel Dos Reis, Bjarne Stroustrup, Jason Merrill, Hubert Tong, Eric Niebler, Casey Carter, Tom Honermann, Erich Keane, Walter E. Brown, Michael Spertus) P1141R2
• 2018-12 Single-file modules with the Atom semantic properties rule (with Jeff Snyder) P1242R1

2019

• 2019-02 Constrained Internal Linkage for Modules (with Chandler Carruth, Nathan Sidwell) P1498R0 P1498R1
• 2019-03 Standard library header units for C++20 P1502R0 P1502R1
• 2019-06 Mitigating minor modules maladies P1766R0 P1766R1
• 2019-06 Packaging C++ Modules P1767R0
• 2019-07 Permit conversions to arrays of unknown bound (with Robert Haberlach) P0388R4
• 2019-08 Relaxing redefinition restrictions for re-exportation robustness (with Gabriel Dos Reis) P1811R0
• 2019-10 if consteval (with Barry Revzin, Daveed Vandevoorde, Andrew Sutton) P1938R0 P1938R1 P1938R2 P1938R3
• 2019-12 Defaulted comparison specification cleanups P2002R0 P2002R1

2020

• 2020-03 Goals and priorities for C++ (with Chandler Carruth, Timothy Costa, Hal Finkel, Dmitri Gribenko, D. S. Hollman, Chris Kennelly, Thomas Köppe, Damien Lebrun-Grandie, Bryce Adelstein Lelbach, Josh Levenberg, Nevin Liber, Chris Palmer, Tom Scogland, David Stone, Christian Trott, Titus Winters) P2137R0

2021

• 2021-10 The Equality Operator You Are Looking For (with Barry Revzin, Bjarne Stroustrup, Cameron DaCamara, Daveed Vandevoorde, Gabriel Dos Reis, Herb Sutter, Jason Merrill, Jonathan Caves, Ville Voutilainen) P2468R0 P2468R1 P2468R2
• 2021-11 Extending class types as non-type template parameters (with Barry Revzin) P2484R0

2022

• 2022-05 Explicit lifetime management (with Timur Doumler) P2590R0 P2590R1 P2590R2
• 2022-10 Fixing std::start_lifetime_as and std::start_lifetime_as_array (with Timur Doumler, Arthur O'Dwyer, Alisdair Meredith, Robert Leahy) P2679R0 P2679R1 P2679R2

CWG

EWG

LWG

CppCon 2016: There and Back Again: An Incremental C++ Modules Design

CppNow 2023: Writing a Lookup Table in C++ (Lightning Talk)

The C++ Contest 2018

• Most Underhanded C++ Contest 2018 (Results & Analysis)

Twitter Quizzes

• Quiz Quick C++20 quiz: Which numbered lines are valid?

  struct A { int x, y; };
  void f(A (&&)[]);
  void g() {
      f({1, 2, 3, 4, 5, 6}); // #1
      (&f)({1, 2, 3, 4, 5, 6}); // #2
      (*f)({1, 2, 3, 4, 5, 6}); // #3
  }

• Quiz Quick C++ quiz: which of these is valid?

  struct T {};
  T *get(int);
  void f() {
      if (T *p = get(0)) { /*...*/ }
      else if (T *p = get(1)) { /*...*/ }
  }
  void g() {
      if (T *p = get(0)) { /*...*/ }
      else { T *p = get(1); /*...*/ }
  }

• Quiz Quick C++ quiz: what does this do?

  #include <stdio.h>
  void f(float&&) { puts("float"); }
  void f(int&&) { puts("int"); }
  void g(auto &&...v) { (f(v), ...); }
  int main() { g(1.0f, 2); }

• Quiz C++ quiz: which of these are valid in C++20?

  const char (&&r1)[3] = {"abc"};
  const char (&&r2)[4] = {"abc"};
  const char (&&r3)[5] = {"abc"};
  const char (&&r4)[] = {"abc"};

• Quiz C++ quiz: what's the value of 'n' after this? (Assume 8-bit char, 32-bit int.)

  unsigned char n = 1;
  n = n << 8;

• Quiz C++ quiz: what happens if you call this function?

  void f() {
      int a[1];
      int *p = a;
      delete p;
  }

• Quiz C++ quiz: can an auto& reference bind to a temporary when the initializer is an lvalue?

  struct A { /*???*/ } a;
  auto &r = a.n; // can bind to a temporary?

• Quiz C++ quiz time! Assuming long long is 64 bits and double is IEEE754 double precision, what happens here:

  long long n = 0x7fff'ffff'ffff'ffff;
  double d = n;
  long long m = d;

• Quiz Quick C++ quiz:

  int n=0x1e+2>>4;

• Quiz C++ quiz time! Without checking, what does this print (assume an LP64 / LLP64 system):

  short a = 1;
  std::cout << sizeof(+a)["23456"] << std::endl;