› P1040R10 std::embed and #depend J. Meneide
Abstract
> I’m very keen on std::embed. I’ve been hand-embedding data in executables for NEARLY FORTY YEARS now. — Guy "Hatcat" Davidson, June 15, 2018
› P2826R3 Expression Aliases G. Ažman
Abstract
This paper introduces a way to rewrite a function call to a different expression without a forwarding layer.
› P3097R2 Contracts for C++: Virtual functions T. Doumler , J. Berne
Abstract
We propose to allow specifying precondition and postcondition assertions on virtual functions, in the same way they can already be specified on non-virtual functions:
› P3098R2 Contracts for C++: Postcondition captures T. Doumler , G. Ažman , J. Berne
Abstract
We propose to add a new, optional syntactic construct to postcondition assertions, called *postcondition* captures. Postcondition captures are spelled in the same fashion as lambda captures. They are placed immediately after the `post` contextual keyword and before the predicate: `post [``captures``] (``predicate``)` Postcondition captures are variables constructed when the function is called. The
› P3099R2 Contracts for C++: User-defined diagnostic messages T. Doumler , P. Bindels , J. Berne
Abstract
A user-defined diagnostic message can provide additional information that can help developers more quickly understand why a particular assertion failed and how to resolve the issue. The ability to optionally provide such a message is valuable for any assertion facility, including contract assertions. The C `assert` macro does not directly support an associated diagnostic message. However, the idio
› P3100R6 A framework for systematically addressing undefined behaviour in the C++ Standard T. Doumler , J. Berne
Abstract
In this paper, we enumerate all cases of core language undefined behaviour explicitly specified in the C++ Standard, group them into ten categories, and classify them along a number of relevant criteria.
› P3377R0 constexpr `reinterpret_cast` partial replacements H. Dusíková , G. Ažman
Abstract
| functionality | runtime only (current status) | runtime & constexpr compatible replacement | status | | --- | --- | --- | --- | | pointer ↔︎ integer | `intptr_t * iptr = reinterpret_cast<intptr_t>(ptr); auto * optr = reinterpret_cast<pointer>(iptr);` | — | not proposed | | pointer tagging | `auto tptr = reinterpret_cast<pointer>( reinterpret_cast<intptr_t>(ptr) \| 0b1u); auto tag = static_cast<b
› P3400R3 Controlling Contract-Assertion Properties J. Berne
Abstract
— Major restructuring: new Introduction, Design, Glossary, expanded Standard Library Additions sections
› P3568R2 break label; and continue label; J. Schultke
Abstract
While C++ already has a broad selection of control flow constructs, one construct commonly found in other languages is notably absent: the ability to apply `break` or `continue` to a loop or `switch` when this isn’t the innermost enclosing statement. This feature is popular, simple, and quite useful:
› P3818R2 constexpr exception library which is unsurprising in potentially constant initialization H. Dusíková
Abstract
To make `constexpr` exception support complete, and allow all functionality withing constant evaluation. This paper was seen in previous revision by LEWG. It didn't get consensus and most of the group prefered the conservative approach of removing `constexpr` from `std::uncaught_exception()` and `std::current_exception()`. The group asked me to revisit this again for C++29.
› P3850R0 A proposed plan for extending Contracts in C++29 T. Doumler , J. Berne
› P3969R1 Fixing std::bit_cast of types with padding bits J. Schultke
Abstract
> The following use of `std::bit_cast` has undefined behavior at compile time: > > ```cpp > constexpr auto x = std::bit_cast<__int128>(0.0L); // GCC accepts (x = 0), Clang rejects > ``` > > That is because an 80-bit x87 `long double` has 6 bytes of padding, and it is undefined behavior to map those padding bits onto non-padding bits in the destination type via `std::bit_cast`. [[bit.cast]](https:/
› P4147R0 constexpr => runtime bridge H. Dusíková
Abstract
This paper introduces a customization point which is called when a constant-evaluated value is moving outside of its constant-evaluation (like initialization of `constexpr` variable, or `consteval` function emitting a value to an expression / function evaluated at runtime).
› P4167R0 reflection annotations to control ADL H. Dusíková
Abstract
This papers provides a customization for ADL via a annotation to add an entity to be associated with a type. It adds a new `<meta>` type to represent the annotation, and it modifies [`[basic.lookup.argdep]`](https://eel.is/c++draft/basic.lookup.argdep)
› P4222R0 An initialization profile B. Stroustrup
Abstract
The initialization profile should be the easiest to define, but there can be no profile that everybody can agree on without discussion and alternative choices. Also, the rules for initialization and uninitialized memory are far more complex than most people are willing to believe. The initialization profile is foundational to just about every profile, so the initialization profile must isolate tho
› P4234R0 $identifiers M. Wippich , M. Çağrı
Abstract
One of the oldest and most widely supported extensions to C++ is allowing `$` in identifiers. This feature's origins predate both standard C++ and standard C. As GCC notes in its [documentation](https://gcc.gnu.org/onlinedocs/gcc/Dollar-Signs.html):
