Embedding (and Extracting) DLLs into EXEs as Binary Resources -- Giovanni Dicanio

Windows EXE files can contain resources, including binary resources. In particular, you can embedd one or more DLLs into an EXE, and then extract them at run-time. Let's learn more about that in the following article:

Embedding (and Extracting) Binary Files like DLLs into an EXE as Resources

by Giovanni Dicanio

From the article:

A Windows .EXE executable file can contain binary resources, which are basically arbitrary binary data embedded in the file.

In particular, it’s possible to embed one or more DLLs as binary resources into an EXE. In this article, I’ll first show you how to embed a DLL as a binary resource into an EXE using the Visual Studio IDE; then, you’ll learn how to access that binary resource data using proper Windows API calls.

(...)

Once you have embedded a binary resource, like a DLL, into your EXE, you can access the resource’s binary data using some specific Windows APIs. (...)

The above “API dance” can be translated into the following C++ code: (...)

I uploaded on GitHub a C++ demo code that extracts a DLL embedded as a resource in the EXE, and, for testing purposes, invokes a function exported from the extracted DLL.

Looking for Pointers: The C++ Memory Safety Debate -- John Farrier

From the White House to the NSA to Bjarne Stroustrup has an opinion on C++ and Memory Safety.  Let's examine this from a historical context and see where this debate may lead.

Looking for Pointers: The C++ Memory Safety Debate

by John Farrier

From the article:

The dialogue around C++ and memory safety has intensified following recent evaluations by authoritative bodies. The White House’s Office of the National Cyber Director issued a compelling call for a pivot toward memory-safe programming languages. This stance is predicated on a history of cyber vulnerabilities linked to memory safety issues, influencing national security and the broader digital ecosystem’s integrity.

This debate takes place against a backdrop of historical precedence, technological evolution, and a reevaluation of programming language safety standards, underscoring the need for a nuanced understanding of memory safety within the context of C++.

When and How Variables are Initialized? - Part 2 -- Sandor Dargo

SANDOR_DARGO_ROUND.JPGDuring the last two weeks, we saw a bug related to uninitialized values and undefined behaviour, we listed the different kinds of initializations in C++ and we started to more detailed discovery with copy-initialization. This week, we continue this discovery with direct-, list- and aggregate-initialization.

When and How Variables are Initialized? - Part 2

by Sandor Dargo

From the article:

Direct-initialization initializes an object from an explicit set of constructor arguments. Different syntaxes invoke direct initialization such as T object(<at least one arg>);T(<at least one arg>); or new T(<at least one arg>); but it might also happen when you use curly braces (T object{oneArg};). Additional use cases are static casts, constructor initializer lists and values taken by value in lambda captures.

While at first glance this might obvious there are some catches.

Take this expression: T object{ arg };. In this case, object is directly initialized only if it’s a non-class type, otherwise, we talk about list-initialization. But if you use the parentheses syntax (T object(arg) then there is no such distinction between class and non-class types, in both cases, direct-initialization is performed. Also, T object{ arg1, arg2 }; would never be direct-initialized, that’s always an aggregate-initialization.

In the expression [arg]() {}, the generated lambda members will not be copy-initialized, but they will be directly initialized.

Overload 180: C++ Safety, In Context -- Herb Sutter

Overload180-Sutter.pngThe safety of C++ has become a hot topic recently. Herb Sutter discusses the language’s current problems and potential solutions.

Overload 180: C++ Safety, In Context

by Herb Sutter

From the article:

We must make our software infrastructure more secure against the rise in cyberattacks (such as on power grids, hospitals, and banks), and safer against accidental failures with the increased use of software in life-critical systems (such as autonomous vehicles and autonomous weapons).

The past two years in particular have seen extra attention on programming language safety as a way to help build more-secure and -safe software; on the real benefits of memory-safe languages (MSLs); and that C and C++ language safety needs to improve – I agree.

But there have been misconceptions, too, including focusing too narrowly on programming language safety as our industry’s primary security and safety problem – it isn’t. Many of the most damaging recent security breaches happened to code written in MSLs (e.g., Log4j [CISA-1]) or had nothing to do with programming languages (e.g., Kubernetes Secrets stored on public GitHub repos [Kadkoda23]).

In that context, I’ll focus on C++ and try to:

  • highlight what needs attention (what C++’s problem is), and how we can get there by building on solutions already underway;
  • address some common misconceptions (what C++’s problem isn’t), including practical considerations of MSLs; and
  • leave a call to action for programmers using all languages.

tl;dr: I don’t want C++ to limit what I can express efficiently. I just want C++ to let me enforce our already-well-known safety rules and best practices by default, and make me opt out explicitly if that’s what I want. Then I can still use fully modern C++… just nicer.

Let’s dig in.

2024-04 Mailing Available

The 2024-04 mailing of new standards papers is now available.

 

WG21 Number Title Author Document Date Mailing Date Previous Version Subgroup
N4974 2024-11 Wroclaw meeting information Herb Sutter 2024-03-18 2024-04   All of WG21
N4975 2024 WG21 admin telecon meetings Herb Sutter 2024-02-21 2024-04   All of WG21
N4976 WG21 agenda: 18-23 March 2024, Tokyo, Japan John Spicer 2024-02-26 2024-04   All of WG21
N4978 WG21 2024-03 Admin telecon minutes Nina Ranns 2024-03-11 2024-04   All of WG21
N4979 Hagenberg Meeting Invitation and Information Peter Kulczycki 2024-03-22 2024-04   All of WG21
N4980 WG21 2024-03 Tokyo Minutes of Meeting Nina Ranns 2024-04-05 2024-04   All of WG21
N4981 Working Draft, Programming Languages -- C++ Thomas Köppe 2024-04-16 2024-04   All of WG21
N4982 Editors' Report, Programming Languages -- C++ Thomas Köppe 2024-04-16 2024-04   All of WG21
P0260R8 C++ Concurrent Queues Detlef Vollmann 2024-03-09 2024-04 P0260R7 SG1 Concurrency and Parallelism,LEWG Library Evolution
P0562R1 Initialization List Symmetry Alan Talbot 2024-03-21 2024-04 P0562R0 EWG Evolution
P0562R2 Trailing Commas in Base-clauses and Ctor-initializers Alan Talbot 2024-04-15 2024-04 P0562R1 CWG Core
P0609R3 Attributes for Structured Bindings Aaron Ballman 2024-03-21 2024-04 P0609R2 CWG Core
P0843R11 inplace_vector Gonzalo Brito Gadeschi 2024-03-21 2024-04 P0843R10 LWG Library
P0876R16 fiber_context - fibers without scheduler Oliver Kowalke 2024-03-22 2024-04 P0876R15 EWG Evolution,CWG Core,LWG Library
P1061R8 Structured Bindings can introduce a Pack Barry Revzin 2024-04-14 2024-04 P1061R7 CWG Core
P1068R11 Vector API for random number generation Ilya Burylov 2024-04-01 2024-04 P1068R10 LWG Library
P1317R1 Remove return type deduction in std::apply Aaryaman Sagar 2024-04-03 2024-04 P1317R0 LEWG Library Evolution
P2034R3 Partially Mutable Lambda Captures Ryan McDougall 2024-03-20 2024-04 P2034R2 EWGI SG17: EWG Incubator,EWG Evolution,CWG Core
P2075R5 Philox as an extension of the C++ RNG engines Ilya Burylov 2024-04-01 2024-04 P2075R4 LEWG Library Evolution,LWG Library
P2127R0 Making C++ Software Allocator Aware Pablo Halpern 2024-03-11 2024-04   LEWG Library Evolution
P2135R1 P2055R1: A Relaxed Guide to memory_order_relaxed Paul E. McKenney 2024-04-09 2024-04 P2135R0 SG1 Concurrency and Parallelism
P2141R2 Aggregates are named tuples Antony Polukhin 2024-03-06 2024-04 P2141R1 LEWG Library Evolution,LWG Library
P2248R8 Enabling list-initialization for algorithms Giuseppe D'Angelo 2024-03-20 2024-04 P2248R7 LWG Library
P2300R8 `std::execution` Eric Niebler 2024-04-02 2024-04 P2300R7 LEWG Library Evolution,LWG Library
P2300R9 `std::execution` Eric Niebler 2024-04-02 2024-04 P2300R8 LEWG Library Evolution,LWG Library
P2355R2 Postfix fold expressions S. Davis Herring 2024-03-20 2024-04 P2355R1 EWG Evolution
P2389R1 `dextents` Index Type Parameter Bryce Adelstein Lelbach 2024-04-12 2024-04 P2389R0 LEWG Library Evolution
P2414R3 Pointer lifetime-end zap proposed solutions Paul E. McKenney 2024-04-08 2024-04 P2414R2 SG1 Concurrency and Parallelism,EWG Evolution
P2542R8 views::concat Hui Xie 2024-03-20 2024-04 P2542R7 SG9 Ranges,LEWG Library Evolution,LWG Library
P2573R2 = delete("should have a reason"); Yihe Li 2024-03-21 2024-04 P2573R1 CWG Core
P2591R5 Concatenation of strings and string views Giuseppe D'Angelo 2024-03-20 2024-04 P2591R4 LWG Library
P2746R5 Deprecate and Replace Fenv Rounding Modes Hans Boehm 2024-04-15 2024-04 P2746R4 SG6 Numerics,LEWG Library Evolution
P2747R2 constexpr placement new Barry Revzin 2024-03-18 2024-04 P2747R1 EWG Evolution
P2748R5 Disallow Binding a Returned Glvalue to a Temporary Brian Bi 2024-03-22 2024-04 P2748R4 CWG Core
P2755R1 A Bold Plan for a Complete Contracts Facility Joshua Berne, Jake Fevold, John Lakos 2024-04-10 2024-04 P2755R0 SG21 Contracts
P2786R5 Trivial Relocatability For C++26 Mungo Gill 2024-04-09 2024-04 P2786R4 EWG Evolution,LEWG Library Evolution
P2795R5 Erroneous behaviour for uninitialized reads Thomas Köppe 2024-03-21 2024-04 P2795R4 SG12 Undefined and Unspecified Behavior,SG23 Safety and Security,EWG Evolution,CWG Core,LWG Library
P2809R3 Trivial infinite loops are not Undefined Behavior JF Bastien 2024-03-21 2024-04 P2809R2 SG22 Compatibility,CWG Core
P2810R4 is_debugger_present is_replaceable René Ferdinand Rivera Morell 2024-03-20 2024-04 P2810R3 LWG Library
P2825R1 Overload Resolution hook: declcall(unevaluated-postfix-expression) Gašper Ažman 2024-03-20 2024-04 P2825R0 EWGI SG17: EWG Incubator,EWG Evolution
P2825R2 Overload Resolution hook: declcall(unevaluated-postfix-expression) Gašper Ažman 2024-04-16 2024-04 P2825R1 EWG Evolution
P2826R2 Replacement functions Gašper Ažman 2024-03-17 2024-04 P2826R1 EWG Evolution
P2830R2 Standardized Constexpr Type Ordering Gašper Ažman 2024-03-17 2024-04 P2830R1 EWG Evolution
P2830R3 Standardized Constexpr Type Ordering Gašper Ažman 2024-04-16 2024-04 P2830R2 EWG Evolution
P2841R2 Concept and variable-template template-parameters Corentin Jabot 2024-02-22 2024-04 P2841R1 EWG Evolution
P2845R7 Formatting of std::filesystem::path Victor Zverovich 2024-03-10 2024-04 P2845R6 LEWG Library Evolution,LWG Library
P2845R8 Formatting of std::filesystem::path Victor Zverovich 2024-03-20 2024-04 P2845R7 LWG Library
P2855R1 Member customization points for Senders and Receivers Ville Voutilainen 2024-02-22 2024-04 P2855R0 LEWG Library Evolution
P2863R5 Review Annex D for C++26 Alisdair Meredith 2024-04-16 2024-04 P2863R4 EWG Evolution,LEWG Library Evolution
P2866R2 Remove Deprecated Volatile Features From C++26 Alisdair Meredith 2024-04-16 2024-04 P2866R1 SG1 Concurrency and Parallelism,LEWG Library Evolution
P2867R2 Remove Deprecated strstreams From C++26 Alisdair Meredith 2024-03-19 2024-04 P2867R1 LWG Library
P2869R4 Remove Deprecated `shared_ptr` Atomic Access APIs From C++26 Alisdair Meredith 2024-03-20 2024-04 P2869R3 LWG Library
P2872R3 Remove `wstring_convert` From C++26 Alisdair Meredith 2024-03-19 2024-04 P2872R2 LWG Library
P2873R1 Remove Deprecated locale category facets for Unicode from C++26 Alisdair Meredith 2024-04-08 2024-04 P2873R0 LEWG Library Evolution
P2875R4 Undeprecate `polymorphic_allocator::destroy` For C++26 Alisdair Meredith 2024-03-20 2024-04 P2875R3 LWG Library
P2893R3 Variadic Friends Jody Hagins 2024-03-21 2024-04 P2893R2 CWG Core
P2900R6 Contracts for C++ Joshua Berne 2024-02-29 2024-04 P2900R5 EWG Evolution,LEWG Library Evolution
P2927R2 Observing exceptions stored in exception_ptr Gor Nishanov 2024-04-15 2024-04 P2927R1 LEWG Library Evolution
P2944R3 Comparisons for reference_wrapper Barry Revzin 2024-03-20 2024-04 P2944R2 EWG Evolution,LEWG Library Evolution
P2977R1 Build database files Ben Boeckel 2024-03-25 2024-04 P2977R0 SG15 Tooling
P2988R4 std::optional<T&> Steve Downey 2024-04-16 2024-04 P2988R3 LEWG Library Evolution,LWG Library
P2993R0 Constrained Numbers Luke Valenty 2024-03-21 2024-04   SG6 Numerics,SG23 Safety and Security
P2997R1 Removing the common reference requirement from the indirectly invocable concepts Barry Revzin 2024-03-21 2024-04 P2997R0 SG9 Ranges,LEWG Library Evolution
P3008R2 Atomic floating-point min/max Gonzalo Brito Gadeschi 2024-03-18 2024-04 P3008R1 LEWG Library Evolution
P3016R3 Resolve inconsistencies in begin/end for valarray and braced initializer lists Arthur O'Dwyer 2024-03-22 2024-04 P3016R2 LWG Library
P3019R7 Vocabulary Types for Composite Class Design Jonathan Coe 2024-03-18 2024-04 P3019R6 LEWG Library Evolution,LWG Library
P3019R8 Vocabulary Types for Composite Class Design Jonathan Coe 2024-03-22 2024-04 P3019R7 LEWG Library Evolution,LWG Library
P3029R1 Better mdspan's CTAD Hewill Kang 2024-03-20 2024-04 P3029R0 LEWG Library Evolution
P3032R1 Less transient constexpr allocation Barry Revzin 2024-03-21 2024-04 P3032R0 EWG Evolution
P3032R2 Less transient constexpr allocation Barry Revzin 2024-04-16 2024-04 P3032R1 EWG Evolution
P3034R1 Module Declarations Shouldn't be Macros Michael Spencer 2024-03-20 2024-04 P3034R0 All of WG21
P3037R1 constexpr std::shared_ptr Paul Keir 2024-03-05 2024-04 P3037R0 SG7 Reflection,LEWG Library Evolution
P3049R0 node-handles for lists Michael Florian Hava 2024-04-03 2024-04   LEWG Library Evolution
P3050R1 Fix C++26 by optimizing linalg::conjugated for noncomplex value types Mark Hoemmen 2024-04-08 2024-04 P3050R0 LEWG Library Evolution
P3064R0 How to Avoid OOTA Without Really Trying Paul E. McKenney 2024-04-05 2024-04   SG1 Concurrency and Parallelism
P3068R1 Allowing exception throwing in constant-evaluation. Hana Dusíková 2024-03-30 2024-04 P3068R0 EWG Evolution
P3072R2 Hassle-free thread attributes Zhihao Yuan 2024-03-17 2024-04 P3072R1 LEWG Library Evolution
P3074R3 trivial union (was std::uninitialized<T>) Barry Revzin 2024-04-14 2024-04 P3074R2 EWG Evolution
P3085R1 `noexcept` policy for SD-9 (throws nothing) Ben Craig 2024-03-17 2024-04 P3085R0 LEWG Library Evolution
P3086R1 Proxy: A Pointer-Semantics-Based Polymorphism Library Mingxin Wang 2024-03-18 2024-04 P3086R0 LEWGI SG18: LEWG Incubator,LEWG Library Evolution
P3086R2 Proxy: A Pointer-Semantics-Based Polymorphism Library Mingxin Wang 2024-04-16 2024-04 P3086R1 LEWG Library Evolution
P3091R1 Better lookups for `map` and `unordered_map` Pablo Halpern 2024-03-22 2024-04 P3091R0 LEWGI SG18: LEWG Incubator
P3094R1 std::basic_fixed_string Mateusz Pusz 2024-03-20 2024-04 P3094R0 SG16 Unicode,LEWG Library Evolution
P3097R0 Contracts for C++: Support for virtual functions Timur Doumler 2024-04-15 2024-04   SG21 Contracts
P3103R1 More bitset operations Jan Schultke 2024-03-07 2024-04 P3103R0 LEWGI SG18: LEWG Incubator
P3104R1 Bit permutations Jan Schultke 2024-03-07 2024-04 P3104R0 LEWGI SG18: LEWG Incubator
P3104R2 Bit permutations Jan Schultke 2024-04-04 2024-04 P3104R1 LEWGI SG18: LEWG Incubator
P3105R1 constexpr std::uncaught_exceptions() Jan Schultke 2024-03-07 2024-04 P3105R0 LEWGI SG18: LEWG Incubator
P3105R2 constexpr std::uncaught_exceptions() Jan Schultke 2024-04-04 2024-04 P3105R1 LEWGI SG18: LEWG Incubator
P3106R1 Clarifying rules for brace elision in aggregate initialization James Touton 2024-03-20 2024-04 P3106R0 CWG Core
P3107R1 Permit an efficient implementation of std::print Victor Zverovich 2024-02-25 2024-04 P3107R0 LEWG Library Evolution
P3107R2 Permit an efficient implementation of std::print Victor Zverovich 2024-03-17 2024-04 P3107R1 LEWG Library Evolution
P3107R3 Permit an efficient implementation of std::print Victor Zverovich 2024-03-18 2024-04 P3107R2 LEWG Library Evolution
P3107R4 Permit an efficient implementation of std::print Victor Zverovich 2024-03-19 2024-04 P3107R3 LEWG Library Evolution
P3107R5 Permit an efficient implementation of std::print Victor Zverovich 2024-03-21 2024-04 P3107R4 LWG Library
P3119R0 Tokyo Technical Fixes to Contracts Joshua Berne 2024-04-04 2024-04   SG21 Contracts
P3122R1 [[nodiscard]] should be Recommended Practice Jonathan Wakely 2024-03-12 2024-04 P3122R0 LEWG Library Evolution,LWG Library
P3135R1 Hazard Pointer Extensions Maged Michael 2024-04-12 2024-04 P3135R0 SG1 Concurrency and Parallelism
P3146R1 Clarifying std::variant converting construction Giuseppe D'Angelo 2024-02-20 2024-04 P3146R0 LEWG Library Evolution,LWG Library
P3147R1 A Direction for Vector Alan Talbot 2024-03-17 2024-04 P3147R0 LEWG Library Evolution
P3149R1 async_scope -- Creating scopes for non-sequential concurrency Ian Petersen 2024-03-13 2024-04 P3149R0 SG1 Concurrency and Parallelism,LEWG Library Evolution
P3149R2 async_scope -- Creating scopes for non-sequential concurrency Ian Petersen 2024-03-20 2024-04 P3149R1 LEWG Library Evolution
P3159R0 C++ Range Adaptors and Parallel Algorithms Bryce Adelstein Lelbach 2024-03-17 2024-04   SG1 Concurrency and Parallelism,LEWG Library Evolution
P3160R1 An allocator-aware `inplace_vector` Pablo Halpern 2024-03-08 2024-04 P3160R0 LEWG Library Evolution
P3161R0 Unified integer overflow arithmetic Tiago Freire 2024-02-17 2024-04   SG6 Numerics
P3161R1 Unified integer overflow arithmetic Tiago Freire 2024-03-13 2024-04 P3161R0 SG6 Numerics
P3162R0 LEWG [[nodiscard]] policy Darius Neațu 2024-02-22 2024-04   LEWG Library Evolution
P3164R0 Improving diagnostics for sender expressions Eric Niebler 2024-02-29 2024-04   LEWG Library Evolution
P3165R0 Contracts on virtual functions for the Contracts MVP Ville Voutilainen 2024-02-26 2024-04   SG21 Contracts
P3166R0 Static Exception Specifications Lewis Baker 2024-03-16 2024-04   EWGI SG17: EWG Incubator,LEWGI SG18: LEWG Incubator
P3167R0 Attributes for the result name in a postcondition assertion Tom Honermann 2024-02-28 2024-04   SG21 Contracts
P3168R0 Give std::optional Range Support David Sankel 2024-02-28 2024-04   LEWG Library Evolution
P3168R1 Give std::optional Range Support David Sankel 2024-04-11 2024-04 P3168R0 LEWG Library Evolution
P3169R0 Inherited contracts Jonas Persson 2024-04-13 2024-04   SG21 Contracts
P3170R0 sinkable exception error message Jarrad J Waterloo 2024-02-29 2024-04   LEWG Library Evolution
P3171R0 Adding functionality to placeholder types Barry Revzin 2024-03-04 2024-04   LEWG Library Evolution
P3172R0 Using `this` in constructor preconditions Andrzej Krzemieński 2024-03-08 2024-04   SG21 Contracts
P3173R0 P2900R6 may be minimimal, but it is not viable Gabriel Dos Reis 2024-03-15 2024-04   EWG Evolution
P3174R0 SG16: Unicode meeting summaries 2023-10-11 through 2024-02-21 Tom Honermann 2024-03-09 2024-04   SG16 Unicode
P3175R0 Reconsidering the `std::execution::on` algorithm Eric Niebler 2024-03-14 2024-04   LEWG Library Evolution
P3176R0 The Oxford variadic comma Jan Schultke 2024-03-07 2024-04   EWGI SG17: EWG Incubator
P3177R0 const prvalues in the conditional operator Barry Revzin 2024-03-17 2024-04   EWG Evolution
P3179R0 C++ parallel range algorithms Ruslan Arutyunyan 2024-03-14 2024-04   SG1 Concurrency and Parallelism,SG9 Ranges
P3180R0 C++ Standard Library Ready Issues to be moved in Tokyo, Mar. 2024 Jonathan Wakely 2024-03-15 2024-04   All of WG21
P3181R0 Atomic stores and object lifetimes Hans Boehm 2024-04-15 2024-04   SG1 Concurrency and Parallelism
P3182R0 Add pop_value methods to container adaptors Brian Bi 2024-04-16 2024-04   LEWG Library Evolution
P3183R0 Contract testing support Bengt Gustafsson 2024-04-15 2024-04   SG21 Contracts
P3187R1 remove ensure_started and start_detached from P2300 Kirk Shoop 2024-03-20 2024-04 P3187R0 SG1 Concurrency and Parallelism,LEWG Library Evolution
P3187R1 remove ensure_started and start_detached from P2300 Kirk Shoop 2024-03-20 2024-04 P3187R0 SG1 Concurrency and Parallelism,LEWG Library Evolution
P3188R0 Proxy: A Pointer-Semantics-Based Polymorphism Library - Presentation slides for P3086R1 Mingxin Wang 2024-04-16 2024-04   LEWGI SG18: LEWG Incubator
P3189R0 Slides for LEWG presentation of P2900R6: Contracts for C++ Timur Doumler 2024-03-18 2024-04   LEWG Library Evolution
P3190R0 Slides for EWG presentation of D2900R7: Contracts for C++ Timur Doumler 2024-03-19 2024-04   EWG Evolution
P3191R0 Feedback on the scalability of contract violation handlers in P2900 Louis Dionne 2024-03-20 2024-04   SG21 Contracts,EWG Evolution
P3192R0 LEWGI/SG18 Presentation of P3104R1 Bit Permutations Jan Schultke 2024-03-19 2024-04   LEWGI SG18: LEWG Incubator
P3194R0 LEWGI/SG18 Presentation of P3105R1 constexpr std::uncaught_exceptions() Jan Schultke 2024-03-19 2024-04   LEWGI SG18: LEWG Incubator
P3196R0 Core Language Working Group "ready" Issues for the March, 2024 meeting Jens Maurer 2024-03-22 2024-04   CWG Core
P3197R0 A response to the Tokyo EWG polls on the Contracts MVP (P2900R6) Timur Doumler 2024-04-12 2024-04   SG21 Contracts,EWG Evolution
P3198R0 A takeaway from the Tokyo LEWG meeting on Contracts MVP Andrzej Krzemieński 2024-03-29 2024-04   SG21 Contracts
P3199R0 Choices for make_optional and value() Steve Downey 2024-03-22 2024-04   LEWG Library Evolution
P3201R0 LEWG [[nodiscard]] policy Jonathan Wakely 2024-03-21 2024-04   LEWG Library Evolution
P3201R1 LEWG [[nodiscard]] policy Jonathan Wakely 2024-03-21 2024-04 P3201R0 LEWG Library Evolution
P3203R0 Implementation defined coroutine extensions Klemens Morgenstern 2024-03-22 2024-04   EWGI SG17: EWG Incubator
P3205R0 Throwing from a `noexcept` function should be a contract violation. Gašper Ažman 2024-04-15 2024-04   SG21 Contracts,EWG Evolution,LEWG Library Evolution
P3207R0 More & like Jarrad J Waterloo 2024-03-24 2024-04   LEWG Library Evolution
P3208R0 import std; and stream macros Sunghyun Min 2024-04-16 2024-04   EWGI SG17: EWG Incubator,LEWGI SG18: LEWG Incubator
P3210R0 A Postcondition *is* a Pattern Match Andrew Tomazos 2024-03-28 2024-04   SG21 Contracts,EWG Evolution
P3211R0 views::transform_join Hewill Kang 2024-04-07 2024-04   SG9 Ranges,LEWG Library Evolution,LWG Library,Direction Group
P3213R0 2024-04 Library Evolution Polls Inbal Levi 2024-04-16 2024-04   LEWG Library Evolution
P3215R0 Slides: Thread Attributes as Designators (P3072R2 presentation) Zhihao Yuan 2024-03-29 2024-04   LEWG Library Evolution
P3216R0 views::slice Hewill Kang 2024-04-07 2024-04   SG9 Ranges,LEWG Library Evolution,LWG Library,Direction Group
P3217R0 Adjoints to "Enabling list-initialization for algorithms": find_last Giuseppe D'Angelo 2024-03-31 2024-04   LEWG Library Evolution,LWG Library
P3218R0 const references to constexpr variables Jarrad J Waterloo 2024-04-09 2024-04   EWG Evolution,CWG Core
P3220R0 views::delimit Hewill Kang 2024-04-16 2024-04   SG9 Ranges,LEWG Library Evolution,LWG Library,Direction Group
P3221R0 Disable pointers to contracted functions Jonas Persson 2024-04-15 2024-04   SG21 Contracts
P3222R0 Fix C++26 by adding transposed special cases for P2642 layouts Mark Hoemmen 2024-04-08 2024-04   LEWG Library Evolution
P3223R0 Making std::basic_istream::ignore less surprising Jonathan Wakely 2024-04-12 2024-04   LEWG Library Evolution
P3224R0 Slides for P3087 - Make direct-initialization for enumeration types at least as permissive as direct Jan Schultke 2024-04-04 2024-04   EWGI SG17: EWG Incubator
P3225R0 Slides for P3140 std::int_least128_t Jan Schultke 2024-04-04 2024-04   EWGI SG17: EWG Incubator,LEWGI SG18: LEWG Incubator
P3226R0 Contracts for C++: Naming the "Louis semantic" Timur Doumler 2024-04-12 2024-04   SG21 Contracts
P3228R0 Contracts for C++: Revisiting contract check elision and duplication Timur Doumler 2024-04-16 2024-04   SG21 Contracts

Results summary: 2024 Annual C++ Developer Survey "Lite"

Over the past week, we ran our 2024 annual global C++ developer surveyThank you to everyone who responded. As promised, here is a summary of the results:

CppDevSurvey-2024-summary.pdf

The results have now been forwarded to the C++ standards committee to help inform C++ evolution. Your feedback will be very helpful, and thank you again for your participation! Stay safe, everyone.

Update to add note: We discovered after the survey went live that SurveyMonkey has started rejecting responses from some countries. They did not notify us this was going to happen, and it means we don't have responses this year from countries that were included in all previous years. We'll look into fixing that for next year because we do want to hear from all C++ programmers worldwide.