C++ - Reddit

C++26: Cleaning up string literals https://www.sandordargo.com/blog/2026/06/10/cpp26-string-literals-cleaned-up https://redd.it/1u238ny @r_cpp

How far can C++20 coroutines go in asynchronous networking? My experience from the runtime to a Redis client library Hi all! I've been playing with C++ coroutines for a few months now. At first, I started building an async runtime based on io_uring to better understand the model of C++ stackless coroutines, and I was amazed by writing asynchronous code that feels just as clean and readable as other languages. Soon, I want to go beyond that and see how far the coroutine model can go in simplifying asynchronous programming. So, I decided to build an asynchronous Redis client library on top of my runtime. During building the Redis client library, I quickly realized that my runtime was missing some utilities for complex workflows, such as the when_all and when_any combinators. But this was resolved quickly under the strong expressive ability of C++ coroutine model, and I finally achieved the simple interface as exactly what I am expecting like this: auto _1, _2, _3, exec_res = coawait redis.multi() .set("user:{1001}", "val1") .set("item:{1001}", val2) .exec(); I've been experimenting with different task types via `promisetype throughout this process, and gained a much deeper understanding of the mechanics behind Awaiter and std::coroutinehandle<>.` So I’m now convinced that the current C++ coroutine model has greatly reduced the complexity of asynchronous programming, **except for the……** **Cancellation** Cancel a single IO such as the `recv/send` seems to be straightforward as the runtime already provides that function. However, things get tricky when you try to extend this ability to a task level. For instance: *Considering Task A is awaiting B or C, and C will await D (A->B/C->D)* In this case, registering every single IO in the async call tree to cancel manually will be a nightmare, we might just want to call A.cancel() or derive a canceltoken from A instead of checking what exactly single IO is in D. Also, The cancellation of C might not affect the B but do cancel the D. `std::execution` describes the `stoppabletoken and setstopped()` to achieve this goal, while it requires very careful implementation of **each** receiver to check the stop token. The coroutine-based IO suggests that the token might be hidden within the `promisetype,as long as the root suspended nodes remember to check if it is stopped and register its callback in the call chain with some tricks in \await_suspend` and `await_transform()` like: template<class Promise> bool awaitsuspend(std::coroutinehandle<Promise> h){ if constexpr( requires{ h.promise().hook(this); } ){ bool stopped = h.promise().hook(this); if(stopped){ return false; } } } It is hard to tell which method is "better" because the cancellation itself is actually scenario-dependent and outside the language core, yet currently I am accepting the second method as it fits my coroutine-based runtime simply. For instance, image that you are awaiting commands to the Redis server, it is hard to give a good definition about the cancellation of that operation, as the TCP packets might already reach the server side. So, in a word, you can achieve a lot with the C++20 coroutine model nowadays, but we still have a lot of open questions to resolve in the asynchronous programming. My Repo if you are interested in. https://redd.it/1u1y6ep @r_cpp

C++20/C++23 Dependency Injection Dependency Injection (DI) is a technique for an object that's being created receive it's dependencies ready for use instead of creating them internally. more about it on the Wiki. DIPP (Dependency Injection for C++) library aims to be as close to .NET's Microsoft DependencyInjection as possible. Why is DIPP interesting: Non intrusive, you can use it with your existing classes. No auto-registration, you must register your services explicitly. All services are registered once (using `dipp::service_collection`) with specified descriptor (scope lifetime (transient, scoped or singleton), object's backing memory and dependencies of the object) and will be later on consumed (using `dipp::service_provider`). Extensible and flexible to define your own service storage, (dipp::service_provider, dipp::service_collection ... are templated storage, defaults to std::map of dipp::move_only_any). DIPP supports two modes, error based return value using Boost.Leaf and exception throwing when attempting to fetch or add a service (check error\_handling.cpp for examples). Similar to .NET, DIPP supports keyed services, as in you can instantiate multiple services of the same type with different keys (check keys.cpp for more examples). struct Engine { Window& window1; Window& window2; Engine(Window& window1, Window& window2) : window1(window1), window2(window2) { } }; // Declare our services using WindowService1 = dipp::injected<Window, ...>; using WindowService2 = dipp::injected<Window, ..., dipp::key("UNIQUE")>; using EngineService = dipp::injected<Engine, ..., dipp::dependency<WindowService1, WindowService2>>; // Create a collection to hold our services dipp::servicecollection collection; // add the services to the collection collection.add<WindowService>(); collection.add<EngineService>(); // create a service provider with the collection dipp::serviceprovider services(std::move(collection)); // Fetch services Engine& engine = services.get<EngineService>(); // both window services shouldn't be the same assert(&engine.window1 != &engine.window2); Mode info: Codeberg: [https://codeberg.org/JassJam/dipp.git](https://codeberg.org/JassJam/dipp.git) Github: https://github.com/JassJam/dipp.git Basic samples in tests [https://codeberg.org/JassJam/dipp/src/branch/main/tests](https://codeberg.org/JassJam/dipp/src/branch/main/tests) Somewhat used through out my (incomplete) toy game engine: https://codeberg.org/JassJam/Neko.git https://redd.it/1u1dyrg @r_cpp

We have colored functions at home https://godbolt.org/z/fsenMderz https://redd.it/1u1eca5 @r_cpp

Boost.Graph Documentation Got a Facelift: Ship it Or Not ? Hi Boost Graph community ! We have taken a first step in modernizing the Boost.Graph documentation with a preview available [here](https://491.graph.prtest3.cppalliance.org/graph/index.html). These first steps aim at solving low-hanging fruits and answering frequent complaints from users collected during the [2022 User Survey](https://www.reddit.com/r/cpp/comments/vyt4t5/boostgraph_user_survey/) and [BGL workshop 2026 ](https://github.com/boostorg/graph/discussions/466) * documentation hard to explore (no table of content, no search bar) * examples use old C++ and several don't even compile * outdated visual design We have been investing into several dimensions: * migrating the old pure html pages to asciidoc + antora * modern examples for each algorithm are compiled and run in CI, with output integrated in the documentation * higher scanability for algorithm complexity + where defined * a better landing for users not familiar with property maps The PR currently sits unmerged as we are trying to assess its viability. Important: * this is NOT the final vision, this is meant as a first important step. * the current scope is NOT a full rewrite/reorganization of each algorithm page. * the current scope is a modernization of the documentation infrastructure. * we are just worried we may have made and missed important mistakes that should prevent the merge Question to the community: 1. Is the [new documentation preview](https://491.graph.prtest3.cppalliance.org/graph/index.html) going in the right direction? 2. Is it better than [the old documentation](https://www.boost.org/doc/libs/1\_91\_0/libs/graph/doc/)? 3. Would you want to see it merged in its current state or did you identify important mistakes we should absolutely fix before merge? Any general complaints not directly related to this PR scope is welcome and will be integrated in future work :) Thank you for your time, https://redd.it/1u18qqv @r_cpp

I asked my c++ professor last semester about using cmake and he did not know what cmake was Is this unusual? Should I avoid his class next semester? There have been quite a few things I have asked him questions about that he has asked me to explain to him what I was even asking about, including cmake and <ranges>. When I asked him about vectors he said to just not use them. It seemed like he had just barely graduated UCB undergrad and was still learning things himself. https://redd.it/1u15vih @r_cpp

two places? If you've built a system that migrated data from a fast ephemeral store to a slower durable one, what triggered the migration and what surprised you about it? Rubén is interested in hearing what actually worked. https://redd.it/1u13p31 @r_cpp

Why we put chat messages in Redis streams (and plan to move old ones to MySQL) The BoostServerTech Chat project stores every message in Redis. An in-memory data store that Rubén Pérez (@anarthal) already knows will need to be replaced for older messages down the road. He did it anyway. Here's why and what the code looks like. Rubén is the author of Boost.MySQL and co-maintainer of Boost.Redis. He built this chat server as a case study in composing Boost libraries for a real application. **The fit** Chat messages have a specific access pattern: append only, read backward (newest first), scoped to a room. Redis streams match this almost exactly. Each room (chat group) is a stream. Writing a message is `XADD`. Reading history is `XREVRANGE`. Redis assigns each entry a unique, time ordered ID, so you get message ordering and cursor-based pagination for free. No schema migrations, indexing decisions, or ORM. A SQL table could do this. But messages are generated at a fast pace and most SQL databases would struggle with this insertion heavy flow. It would require serious performance tuning for a workload that Redis handles natively. **Storing a message** When a user sends a message, the server appends it to the room's Redis stream. The "\*" tells Redis to auto assign a stream ID: // Compose the request. XADD appends to the room's stream // and auto-assigns an ID. redis::request req; for (const auto& msg : messages)     req.push("XADD", room_id, "*", "payload",              serialize_redis_message(msg)); // Execute it. All XADDs go out in one round trip. redis::generic_response res; error_code ec; co_await conn_.async_exec(req, res, asio::redirect_error(ec)); Three things worth noting: 1. Multiple `XADD` commands get pushed into a single `redis::request`. Boost.Redis pipelines them over one connection, so even if a client sends several messages at once, it's one round trip. 2. This is a C++20 coroutine. The `co_await` suspends until Redis responds, but the thread is free to handle other work while it waits. 3. XADD accepts an arbitrary list of (key, value) string pairs. We are using a single key named “payload” that contains the message serialized as JSON. This allows arbitrary nesting. **Serialization without boilerplate** Each message is stored as a JSON payload inside the stream entry. The wire format is a simple struct: struct redis_wire_message {     std::string_view content;     std::int64_t timestamp;     std::int64_t user_id; }; BOOST_DESCRIBE_STRUCT(redis_wire_message, (), (content, timestamp, user_id)) That `BOOST_DESCRIBE_STRUCT` macro registers the struct's members for compile time reflection. Boost.JSON picks it up automatically: `boost::json::value_from(msg)` serializes it, `boost::json::try_value_to<redis_wire_message>(jv)` deserializes it. No hand-written `to_json/from_json` functions. Add a field to the struct and the serialization updates itself. This is one of those spots where Boost libraries click together in a way that's hard to replicate with unrelated dependencies. Describe provides the reflection, JSON consumes it. Three lines replace what would otherwise be two hand maintained serialization functions. **The tradeoff** Redis keeps everything in memory. That's what makes it fast, and it's also the obvious problem. Right now, the server runs with Redis persistence enabled, so data survives restarts. But as message volume grows, keeping the full history in RAM stops making sense. The plan is to eventually offload old messages to MySQL for archival. The message layer is already isolated behind its own service interface, so swapping in a tiered storage strategy (recent messages from Redis, older ones from MySQL) touches one component. Nothing else needs to know. But "eventually" involves a lot. The migration boundary is full of questions. Do you move messages after a time window? After a count threshold? Do you do it inline during reads, or as a background job? What happens to cursor based pagination when the data lives in

ACCU Overload Journal 193 June 2026 https://accu.org/journals/overload/overload193 https://redd.it/1u113rv @r_cpp

The fastest JVM is the C++26 compiler https://wrocpp.github.io/posts/fastest-jvm-is-cpp26 https://redd.it/1u0piiv @r_cpp

New C++ Conference Videos Released This Month - June 2026 **C++Online** 2026-06-01 - 2026-06-07 * Writing C++ Code is Challenging, Writing Performant C++ Code is Daunting - Dmitrii Radivonchik - [https://youtu.be/R2sm9mailuU](https://youtu.be/R2sm9mailuU) * Case Study - Purging Undefined Behavior and Intel Assumptions in a Legacy Codebase - Roth Michaels - [https://youtu.be/H-dHTeSR\_n8](https://youtu.be/H-dHTeSR_n8) **ADC** 2026-06-01 - 2026-06-07 * Beyond the DAW - Designing a Procedural Sequencer Powered by Music-Theory - Romy Dugue & Cecill Etheredge - [https://youtu.be/48sH4wQUDAs](https://youtu.be/48sH4wQUDAs) * From DAW Users to Audio Developers - Teaching JUCE to Creative Minds - Milap Rane - [https://youtu.be/200UrugEanY](https://youtu.be/200UrugEanY) * Music Design and Systems - Achieving Inaudibly Complex Systems in Video Games - Liam Peacock - [https://youtu.be/R6raBvCNsQo](https://youtu.be/R6raBvCNsQo) * Developing for Avid’s Audio Ecosystem - Rob Majors - [https://youtu.be/91-7YWVKRE4](https://youtu.be/91-7YWVKRE4) **CppCon** 2026-06-01 - 2026-06-07 * Lightning Talk: Navigating Code Reviews as a Code Author - Ben Deane - [https://youtu.be/zygtgvHp\_MM](https://youtu.be/zygtgvHp_MM) * Lightning Talk: Eight Consteval Queens and Compile-Time Printing - Sagnik Bhattacharya - [https://youtu.be/gNPhJrXLiIs](https://youtu.be/gNPhJrXLiIs) * Instrumenting the Stack: Strategies for End-to-end Sanitizer Adoption - Damien Buhl - [https://youtu.be/TSrymTXw5w8](https://youtu.be/TSrymTXw5w8) https://redd.it/1u0bqts @r_cpp

I built an ECS framework using C++26 static reflection features. Hey all! Lately, I've been experimenting with C++26 static reflection features using Bloomberg's clang-p2996 compiler fork. I've tried a few different ideas, but this project has definitely been the most exciting for me. The goal was to build an ECS framework that completely eliminates boilerplate setup. Things like manual component registration, system scheduling, and etc...After a few iterations and millions of demonic consteval errors, I've finally gotten it to a state where I feel like I can share it with public. Here is RECS (Reflected Entity Component System) https://github.com/bestofact/recs Since this relies heavily on P2996, it's highly experimental, but it’s been a really nice exercise in pushing meta programming to its limits. Would be really nice to hear your thoughts on the RECS or any general feedback on the code. https://redd.it/1u02jb6 @r_cpp

Vcpkg How to make vcpkg install app files for vulkan and glfw, every time I try, files like vulkanexamplebase.h don't install anywhere or file like glfw3.dll doesn't open for the compiler "I use the purple visual studio, not the visual studio code" https://redd.it/1tzxbsa @r_cpp

Tobias Hieta: A Brief Overview of the LLVM Architecture https://youtu.be/g96voy6M6xo https://redd.it/1tziq6s @r_cpp

Parsing Expression Grammar Template Library (PEGTL) 4.0.0 Released Hello, version 4.0.0 of the PEGTL has been released! For those not familiar, let me quote the first sentence of the documentation: "The Parsing Expression Grammar Template Library (PEGTL) is a zero-dependency C++ header-only parser combinator library for creating parsers according to a Parsing Expression Grammar (PEG)." The basics are still the same, grammars are implemented in C++ with nested template instantiations, however a lot has also changed. Some highlights: * Switched to Boost Software License * A bunch of new parsing rules and actions. * The inputs have been rewritten from scratch. * Nested exceptions are used for nested parsing errors. * Native support for parsing sequences of arbitrary objects. This is the last major version that will stick with C++17. Repository page: https://github.com/taocpp/PEGTL Release page: https://github.com/taocpp/PEGTL/releases/tag/4.0.0 https://redd.it/1tzfwyf @r_cpp

Performance Battle: Mutex vs CAS vs TAS vs Intel TSX Performance Battle: Mutex vs CAS vs TAS vs Intel TSX std::mutex: A standard C++ lock object that provides mutual exclusion between threads. CAS (Compare-And-Swap): An atomic operation that updates a memory location only if its current value matches an expected value. TAS (Test-And-Set): An atomic operation that reads and sets a value simultaneously. Intel TSX (Transactional Synchronization Extensions): An Intel technology that uses hardware transactional memory to reduce lock contention. The following algorithm uses multiple threads to add 1 to a shared memory variable kLoop times. In this case, the sum of sum_atomic and sum_critical_section will be equal to kLoop. Although this is a highly inefficient algorithm, let's just accept it. int sumcriticalsection; std::atomic<int> sumatomic; void Thread() { constexpr auto kLoop{ 2200'0000 }; constexpr auto kNumThread{ 88 };     for (int i = 0; i < kLoop / kNumThread; ++i) {         if (TryAcquire()) {             sumcriticalsection += 1;             Release();         } else {             sumatomic.fetchadd(1, std::memoryorder::relaxed);         } Idle(idletime);     } } An idle period was inserted between work units to control the level of contention. (high contention: 0.6 us / low contention: 3.0 us) `TryAcquire` are implemented as follows. 1. Mutex `return mx.trylock(); 2. CAS return not atomic_bool.load(std::memory_order::relaxed) and atomic_bool.compare_exchange_strong(expected, true, std::memory_order::acquire, std::memory_order::relaxed)); // expected = false 3. TAS return not (atomic_flag.test(std::memory_order::relaxed) or atomic_flag.test_and_set(std::memory_order::acquire)); 4. Intel TSX return _xbegin() == _XBEGIN_STARTED; For both CAS and TAS, the lock variable is checked before attempting the atomic operation. If the lock is already set (true), the function immediately returns false without performing the CAS or TAS operation. Otherwise, performance will degrade. System Description |CPU|2 × Intel Xeon E5-2696 v4 (total 88-thread)| |:-|:-| |Build|C++23, g++ 13.3.0, -Ofast| The experiments were conducted on a two-node NUMA system. Accordingly, both sumcriticalsection and sumatomic` were split into two separate counters. Which of these four approaches do you think will win: Mutex, CAS, TAS, or Intel TSX? Let's keep the rules simple: the winner is whichever finishes the workload the fastest. . . . . . . . . High Contention: idle time = 0.6 us ||sum\critical_section|sum_atomic|elapsed_seconds| |:-|:-|:-|:-| |Mutex|478K|21.5M|1.618| |CAS|557K|21.4M|0.569| |TAS|564K|21.4M|0.567| |TSX|746K|21.2M|0.492| Low Contention: idle time = 3.0 us ||sum_critical_section|sum_atomic|elapsed_seconds| |:-|:-|:-|:-| |Mutex|915K|21.1M|1.835| |CAS|1.90M|20.1M|1.254| |TAS|1.95M|20.0M|1.264| |TSX|10.2M|11.7M|1.142| The winner of this benchmark is Intel TSX. Of course, a benchmark win doesn't automatically make TSX superior in every situation. That said, it did win this round. (when the idle time was zero, TSX, CAS, and TAS achieved nearly identical elapsed times, whereas std::mutex was consistently slower.) What are your thoughts on this matchup? = https://redd.it/1tzey4h @r_cpp

confusion surrounding headers and header guards so im trying to write programs in multiple files however if i include header files more than once it'll cause an error but if i make header guards if the file has already been included it wont be included again which would cause the things i need from my headers to not be included, can anyone try to explain how i should handle this or send github repos to small projects that show how you should handle this https://redd.it/1tzd5hg @r_cpp

Your stdlib implementation matters more than the dispatch pattern https://shubhankar-gambhir.github.io/posts/your-stdlib-implementation-matters-more-than-the-dispatch-pattern/ https://redd.it/1tzda95 @r_cpp

Recent LLVM hash table improvements https://maskray.me/blog/2026-06-07-recent-llvm-hash-table-improvements https://redd.it/1tz3id7 @r_cpp

Is this the most useless piece of code, or what? class IBaseTool { public: virtual ~IBaseTool() = default; }; And it's ONLY other use: class ITool : IBaseTool { public: ITool() = default; ~ITool() override = default; ... } I'm pretty certain this is the most useless piece of code I've seen in over a decade. Please tell me this is physically hurting other people too. https://redd.it/1tyzgmj @r_cpp