C++ - Reddit

New C++ Conference Videos Released This Month - October 2026 **C++Now** 2026-09-28 - 2026-10-04 * What Every C++ Programmer Needs to Know About AI - Jody Hagins - [https://youtu.be/ZBXHPKVCa8E](https://youtu.be/ZBXHPKVCa8E) * SPL - Open Source, Constexpr Library for Composing Algorithms - John Bandela - [https://youtu.be/96AGjm3uwko](https://youtu.be/96AGjm3uwko) * Senders For Existing Asynchronous Interfaces - Dietmar Kühl - [https://youtu.be/96AGjm3uwko](https://youtu.be/96AGjm3uwko) **ACCU** 2026-09-28 - 2026-10-04 * Refactoring Towards Structured Concurrency - Roi Barkan - [https://youtu.be/ttoQfPP\_Gkg](https://youtu.be/ttoQfPP_Gkg) * Design Patterns - The Most Common Misconceptions (3 of N) - Klaus Iglberger - [https://youtu.be/bAsJvmtYZOg](https://youtu.be/bAsJvmtYZOg) * One Lib to Rule Them All and in the Darkness bindgen… - Antonello Palazzi & Kay Hicketts - [https://youtu.be/9BpVjPKv02s](https://youtu.be/9BpVjPKv02s) **ADC** 2026-09-28 - 2026-10-04 * Designing Interactive Music Experiences in XR - Kasson Crooker - [https://youtu.be/J3sVHT8luKs](https://youtu.be/J3sVHT8luKs) * When (Not) to Patent Audio Software - Simon Hestermann - [https://youtu.be/stBB1JoKQiY](https://youtu.be/stBB1JoKQiY) * Distribution Strategies for Indie Audio Developers - From Plugin to Product - Dani Karanyi - [https://youtu.be/Piar49uTjtg](https://youtu.be/Piar49uTjtg) https://redd.it/1wyanqb @r_cpp

Profiles and Contracts - Type/Memory Safety in C++? With the massive push for memory and type safety right now, there is a lot of talk in the C++ community about "profiles" and "contracts." They get grouped together a lot, but they solve entirely different problems. Simply put: Profiles act as a set of global static rules that the compiler enforces to restrict the language itself. Contracts act as local conditions (both pre and post) which enforce your own API logic. Here's some more breakdown between the two: Contracts let you formalize your code's assumptions with pre, post, and contract_assert. To explain the difference between the three: `pre` refers to preconditions, these are appended to function declarations and serve to evaluate predicates before the function body executes. If that condition evaluates to false, then the contract is broken. This can lead to things such as the program crashing or logging the error. post refers to postconditions, which are also appended to function declarations but evaluate the state of your data after the function finishes running. They act as a guarantee to whoever called your function. `contract_assert` lets the programmer specify properties of the program's state that are expected to be held up at certain points. Here's a code example: #include <iostream> // Simple function showing where the contract keywords go int divide_numbers(int numerator, int denominator) pre (denominator != 0) // pre: Cannot divide by zero post (result : result <= numerator) // post: Result must be <= numerator { // Internal assertion: Sanity check an internal assumption contract_assert(numerator >= 0); return numerator / denominator; } int main() { // Compiles perfectly! However, at runtime, this triggers a precondition failure // and terminates the program before ever hitting the internal contract_assert. i

implement first? ... Which one do you think is superior in terms of design and implementation? ... Which has you more excited? https://redd.it/1wxt0i0 @r_cpp

Push-based vs Pull-based Customization https://brevzin.github.io/c++/2026/09/14/push-vs-pull/ https://redd.it/1wge3dj @r_cpp

Measuring the Performance of Deterministic Exceptions https://databasearchitects.blogspot.com/2026/09/measuring-performance-of-deterministic.html https://redd.it/1wyg6ee @r_cpp

Notes on dllexport and dllimport https://www.hanshq.net/dllexport.html https://redd.it/1wyhr4b @r_cpp

What’s New for C++ Developers in Visual Studio 2026 (18.7 – 18.10) https://devblogs.microsoft.com/cppblog/whats-new-for-c-developers-in-visual-studio-2026-18-7-18-10/ https://redd.it/1wfx59b @r_cpp

University of Waterloo user study on understanding CMake changes Hi everyone, I’m Mattie Nejati, a Ph.D. candidate at the University of Waterloo. I’m conducting a user study on understanding the impact of changes to CMake build specifications, and I’d love to invite members of this community to participate. We are evaluating a new approach that aims to help developers identify how a change to a CMake build specification affects the resulting build configuration. The study: is conducted entirely online; takes about one hour; involves inspecting changes to CMake build specifications and identifying their impact; and is open to adults aged 18–64 with any level of experience in CMake, programming, or code review. You do not need to be a CMake expert. We are specifically interested in comparing participants with different levels of experience. You will need a computer with internet access and about 4 GB of free space to download the files required for the tasks. We will not collect your name. Your email address will only be used for study follow-up and will be stored separately from your study data. Your name or email will not appear in any dataset or publication. The study has received clearance from the University of Waterloo Research Ethics Board (REB #46621). If you’re interested, you can find the consent form, screening questionnaire, and study here: https://buiscout.cs.uwaterloo.ca/ Thank you very much! And if you know someone else who works with CMake who might be interested, I’d really appreciate you sharing the study with them. https://redd.it/1wyp45m @r_cpp

operator<>: A Dream of Higher-order Metaprogramming Parity https://www.elbeno.com/blog/?p=1871 https://redd.it/1wfuo4i @r_cpp

C++20 modules support: 228 projects already available to be consumed Hello everyone. I checked arewemodulesyet.org, which I do from time to time. I was very positively surprised bc a couple of months ago there were 109 projects with modules support. Now it is 228 and some of the most popular are there: fmt, ftxui, nlohmann.json and others. So I had to share it with the community. https://redd.it/1wfbh1d @r_cpp

No, -Wall -Werror Does Not Guarantee Detection of Conditionally Uninitialized Local Variables There seems to be a misconception or lack of clarity about the usage of the compilation flags -Wall and -Werror and their ability to detect uninitialized stack variables. It depends. In this post, I will try to explore this further and explain when and how it is detected, and where it may not detect an uninitialized local variable and hence requires more caution while dealing with it. Consider the following code: int main() { int value; return value; } Compile this code as follows: ~/cpp_26_uninitialised$ g++ -std=c++23 -Wall -Werror test.cpp -o test test.cpp: In function ‘int main()’: test.cpp:4:12: error: ‘value’ is used uninitialized [-Werror=uninitialized] 4 | return value; | ^~~~~ test.cpp:3:9: note: ‘value’ was declared here 3 | int value; | ^~~~~ cc1plus: all warnings being treated as errors So, with the use of the two compilation flags, `-Wall` and `-Werror`, the compilation fails, and you can then take corrective measures to address the uninitialized variable in the code. Strictly speaking, -Wall enables the -Wuninitialized warning, and -Werror turns that warning into an error. However, *this is true only when the variable is uninitialized on every path to its use*, as `value` is here. It doesn't reliably work for a variable that is initialized on some paths and left uninitialized on others. Have a look at the following code: // config_timeout_warning_test.cpp #include <charconv> #include <cstdio> #include <string_view> constexpr int default_timeout_ms = 1000; // Reads "timeout_ms=<number>" from a device configuration line. // The bug: when the key is missing, timeout_ms is never assigned. [[gnu::noinline]] int read_timeout_ms(std::string_view config) { int timeout_ms; constexpr std:

==2896379== logger no timeout configured, using default 1000 ms ==2896379== ==2896379== HEAP SUMMARY: ==2896379== in use at exit: 0 bytes in 0 blocks ==2896379== total heap usage: 2 allocs, 2 frees, 74,752 bytes allocated ==2896379== ==2896379== All heap blocks were freed -- no leaks are possible ==2896379== ==2896379== For lists of detected and suppressed errors, rerun with: -s ==2896379== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) You can see Valgrind is complaining about an uninitialized variable created on the stack: Uninitialised value was created by a stack allocation The reason is that GCC handles the two cases with two different warnings. In the first example, value is uninitialized on every path, and -Wuninitialized reports it even at `default` \-O0. In the second example, timeout\_ms is assigned only inside the if block in read\_timeout\_ms(), so it is uninitialized on only one path. That case belongs to -Wmaybe-uninitialized, which relies on the data-flow analysis done by the optimizer, so it does not run at -O0. If you build the same file at -O2, GCC does catch it: ~/cpp_26_uninitialised$ g++ -std=c++23 -O2 -Wall -Werror config_timeout_warning_test.cpp -o timeout_warning_test config_timeout_warning_test.cpp: In function ‘int read_timeout_ms(std::string_view)’: config_timeout_warning_test.cpp:24:12: error: ‘timeout_ms’ may be used uninitialized [-Werror=maybe-uninitialized] 24 | return timeout_ms; | ^~~~~~~~~~ config_timeout_warning_test.cpp:11:9: note: ‘timeout_ms’ was declared here 11 | int timeout_ms; | ^~~~~~~~~~ cc1plus: all warnings being treated as errors This is still not a guarantee. The result of -Wmaybe-uninitialized depends on the optimization level and on how much the optimizer can see, so it can change between GCC versions and between builds. Debug builds are usually at -O0, which i

It annoys me that coroutines are described as "functions that can be suspended" Any function can be suspended. It literally happens constantly when a process or thread gets pre-empted by the OS or asynchronous hardware, with the stack being the mechanism to save to and restore context from. So, this super common way of describing coroutines is just frustrating because it's not it! Coroutines are functions that can be suspended in a **controlled, intentional (as in, explicitly expressed) way**, with the relevant context (coroutine frame) being placed _not_ on the stack like a function's usual context, but on the heap (usually). I wish someone had broken it down for me in this way before, so hopefully it helps someone else too. https://redd.it/1wgm4jx @r_cpp

Jonas Persson: Making every byte count https://youtu.be/GbwrztrY4kc https://redd.it/1wf1l3o @r_cpp

Why do people on Windows mostly choose Visual Studio? https://redd.it/1weku08 @r_cpp

How I speed up my overall build times by 4x and incremental builds by 9x for test builds * I used faster tools: * I switched from lld to mold optimized it mimalloc + pgo + lto + bolt (1.2x-3x faster than system lld) * I optimized clang with mimalloc + pgo + lto + bolt (1.8x-1.85x faster than system clang) * I optimized clang-scan-deps with mimalloc + pgo + lto + bolt (4x faster than system scanner) * I used dynamic linking(3x-4x overall, much larger if you are editing tests) * I used prebuilt binaries via packages rather than vendoring my deps.(huge) * I switched fully to C++ modules(Incremental compilation times are so fast link times dominate now) https://redd.it/1wet7rn @r_cpp

WasmBolt — The LLVM Project in your browser https://anutosh21.github.io/WasmBolt/ https://redd.it/1wcbjng @r_cpp

I built MrDocs, an open-source C++ reference doc generator on the Clang/LLVM AST. Looking for feedback. I'm Alan de Freitas, the lead developer of MrDocs. It's an open-source documentation generator from the C++ Alliance, built on Clang/LLVM. It reads your code from the compiler's AST, so the reference matches what the code actually compiles to. We also presented [a session](https://cppcon2026.sched.com/event/2RT70/mrdocs-reliable-reference-documentation-for-c++-using-the-clang-ast) about it at cppcon this year. I implemented the tool this way because we couldn’t come up with a workflow that understood modern C++ in our Boost libraries. Tools that parse partially tend to misrender or not render concepts, niebloids, SFINAE, overload sets, and deduction guides. MrDocs treats those as first-class: * concept constraints and requires clauses preserved verbatim * niebloids and function objects can be documented as callables * SFINAE and concept overload sets kept together * explicit, noexcept, and consteval specifiers captured * types in detail or private namespaces rendered as implementation-defined The presentation layer is completely encapsulated. Generators support HTML, AsciiDoc, XML, JSON, or any custom format like Markdown and LaTeX, without forking the tool or creating another post-processing workflow. You can also write extensions to apply project conventions to the corpus or define new generators for any use case. The documentation has lots of examples. If you maintain reference docs for a library, I'd appreciate it if you gave it a run (or tell your favorite agent to) and reported back on whether it saves you time, both while writing docs and while reviewing them. First-hand numbers would be especially useful to me. Issues are also always welcome. Site:[ https://www.mrdocs.com](https://www.mrdocs.com/)Repo:[ https://github.com/cppalliance/mrdocs](https://github.com/cppalliance/mrdocs) Happy to answer questions in the comments. https://redd.it/1wz3115 @r

MSVC Build Tools Preview updates – September 2026 https://devblogs.microsoft.com/cppblog/msvc-build-tools-preview-updates-september-2026/ https://redd.it/1wbyyim @r_cpp

When (Not) to Use alloca() https://voithos.io/articles/when-not-to-use-alloca/ https://redd.it/1wbyuv3 @r_cpp

boost.org has been rebuilt: new profiles, badges, search, and library filtering The Boost website has been rebuilt. Here's a summary of what's changed: Updated look and feel, with revised site navigation New user profile pages Badges tied to contribution and participation, which update as you contribute Community features, including posts filtered by the topic of the page you're viewing Site-wide search available from a search box in the header and via Ctrl+K Library search and filtering, including browsing by category The libraries, release process, and formal review process are unchanged. The work is limited to the website itself and how you navigate, search, and contribute to it. Link: boost.org Bug reports and feedback on navigation or search are welcome. https://redd.it/1wbnddw @r_cpp