-
Stay up-to-date with everything C++! Content directly fetched from the subreddit just for you. Join our group for discussions : @programminginc Powered by : @r_channels
GitHub rigx, toml->nix build system for c/cpp/go/zig/etc. Looking for fedback
https://github.com/unofficialtools/rigx
https://redd.it/1tecym6
@r_cpp
- YouTube The Story of C++ documentary trailer in live on CultRepo
https://youtu.be/NXwTRzywDSk?si=8sZEwFUdZW2-Kir4
https://redd.it/1tdolzg
@r_cpp
C++26 Shipped a SIMD Library Nobody Asked For
https://lucisqr.substack.com/p/c26-shipped-a-simd-library-nobody
https://redd.it/1tdhnxj
@r_cpp
C++: The Documentary TRAILER│COMING JUNE 4th
https://youtu.be/NXwTRzywDSk?is=zkrD4Ae_mnrbvSFq
https://redd.it/1td81ye
@r_cpp
MSVC Build Tools Preview updates - May 2026
https://devblogs.microsoft.com/cppblog/msvc-build-tools-preview-updates-may-2026/
https://redd.it/1td2j53
@r_cpp
Encountered a #pragma once failure in the wild
A header-only C++ library, headers guarded by #pragma once. We use relative includes internally. We also ship compiled WASM bindings for TypeScript.
A dockerised emscripten build on Apple Silicon under linux/amd64 emulation, the repo mounted in as a bind volume. Every translation unit reports redefinition errors: the same headers included multiple times in a single TU.#pragma once dedupes by file identity; inode and device, in practice. On a bind mount under amd64 emulation on macOS, the same file reached through different ..-laden relative paths is not always recognised as the same file. The pragma never fires.
The problem goes away if you copy the source files into the container.
https://redd.it/1tcxu2s
@r_cpp
that such dependencies will need private access to each other anyway.
If you want hierarchy (and encapsulation), use dots in the module name like so: 'mylib.class.dep1', 'mylib.class.dep2'. This declares two modules (that will actually be compiled separately). Without exposing private members (with this proposal).
So, TL;DR: Modules could make PIMPL redundant by:
* allowing users to skip importing depended modules if no functions or classes from that module are actually exposed or exported by the parent
* allowing module implementation units to access private members of classes defined within that module
https://redd.it/1tcsv0c
@r_cpp
Your C++ struct is the schema: a proto3 serializer in C++26 reflection
I built a header-only proto3 wire-format library with one constraint: no .proto files, no codegen, no descriptor runtime. The user writes a plain C++ struct, and that struct is the schema:#include "proto3.hpp" struct SearchRequest { std::string query; // field 1 std::int32_t page_number; // field 2 std::int32_t results_per_page; // field 3 }; SearchRequest req{"hello", 1, 10}; std::string bytes = proto3::serialize(req); // -> proto3 wire bytes SearchRequest back = proto3::deserialize<SearchRequest>(bytes);
blog: Your C++ struct is the schema: a proto3 serializer in C++26 reflection
github: struct\_proto26
https://redd.it/1tcrfz4
@r_cpp
Build a Full-Featured Text Editor From Scratch — Architecture, Design Patterns & Complete Checklist
https://0xkiire.com/build-text-editor-from-scratch/
https://redd.it/1tbt2pn
@r_cpp
C++ Standard practices
Hi guys, I am working as a C++ dev at a product based company but I feel I lack certain coding guidelines. Can anyone guide me on how do I design distributed systems and microservice architecture with C++.
Which resources I can refer?
https://redd.it/1tbolx8
@r_cpp
MSVC Build Tools v14.51 now generally available
https://devblogs.microsoft.com/cppblog/msvc-version-1451-available/
https://redd.it/1tbbdns
@r_cpp
Pre-Brno Mailing
The Pre-Brno "enhanced mailing" is here
https://wg21.org/mailing/2026-05/
https://redd.it/1tb896e
@r_cpp
What the heck is Reflection?
https://www.murathepeyiler.com/what-the-heck-is-reflection/
https://redd.it/1tb16ck
@r_cpp
std::optional equality comparison operator seems broken for nested optionals
While chasing a bug in a program I found out that equality comparison operator T vs optional<T> is broken if T is optional<U>. It is broken in worst possible way - it compiles but for some values it returns wrong results!
Here is an example:
https://godbolt.org/z/v3bcTodGj
Since both sides of eq operator are specialization of optional then following overload is used:operator==(const optional<T>& lhs, const optional<U>& rhs);
This operator is specified to return lhs.has_value() != rhs.has_value() ? false : (lhs.has_value() == false ? true : *lhs == *rhs)
This falls apart for above scenario since lhs has value while rhs no value.
Since this is a case of optional<T>{} == T{} comparison, such scenario should be handled separately. Here is my attempt at fixing it:
https://godbolt.org/z/Yq3nM4xn4
This is rather not a proper fix, since it will still break for cases like optional<optional<short>>{} == optional<int>{}, and the internal if-constexpr instead should probably compare the nestedness of lhs and rhs optional.
I didn't check but most likely the same problem applies to relational operators.
https://redd.it/1tafsep
@r_cpp
DBC -> strongly typed Rust/C++ CAN codegen for my bachelor's thesis: feedback wanted
Hey r/cpp,
For my bachelor's thesis, we have been working on dbc-codegen2, an open-source Rust library + CLI that turns DBC files into strongly typed CAN frame code for Rust or C++.
It generates message structs/classes, typed getters/setters, value enums, encode/decode helpers, frame ID and payload length checks, mux handling, and optional generated tests.
dbc-codegen2 gen vehicle.dbc -o generated/vehiclecan --lang rust --test
dbc-codegen2 gen vehicle.dbc -o generated/vehiclecan --lang cpp --test
We are looking for feedback from people using CAN, and especially DBC files, in their projects.
What is missing? What is annoying?
If you have time, we also made two surveys with 4 hands-on tasks each. They take about 25 minutes, so if that is too much, any feedback in the comments is also very welcome:
Rust code generation: [https://forms.gle/9r77YjNDfSXQYRJC6](https://forms.gle/9r77YjNDfSXQYRJC6)
C++ code generation: https://forms.gle/xZQrV4Am4drb7PCx8
Repo/crate: https://github.com/iColgateZz/dbc-codegen2
Disclosure: I am one of the people building it, and this is part of my bachelor's thesis. Not trying to do a drive-by ad; comments with blunt feedback are just as useful as survey responses.
https://redd.it/1taadno
@r_cpp
FYI: Class Template Argument Deduction (CTAD) does not compose well with Designated Initializers
I've been playing around with Designated Initializers lately to see if I can use them for robust NAMED function parameters. It seemed promising at first, but I've hit a wall when it comes to type deduction.
Instead of explaining all the steps, I'll just share where things ended up. So to define an API that uses designated initializers and CTAD, you end up with something like this:
struct NotProvided {};
template <
typename Size = NotProvided,
typename Capacity = NotProvided,
typename Factory = NotProvided
\>
struct Params {
Size size = {};
Capacity capacity = {};
Factory factory = {};
};
template <typename T>
struct Vector {
Vector(auto params) {
// ...pick apart the Params object...
}
};
You can and should make use of concepts to give more type information to the caller. Unconstrained templates are not as helpful when debugging, but I'm using them here to clarify the problem.
So given a callsite like this:
int64_t counter = 0;
auto v1 = Vector<int64_t>(Params{
.size = 0,
.capacity = 10,
.factory = [&\](int64_t* addr) {
::new (addr) int64_t(counter);
\++counter;
},
});
This should work fine and was what got me excited about the prospects of things. But once I started actually writing types like Vector and their tests, I kept getting surprising template error messages. One category was the deduction of reference types instead of underlying value types. That alone is infuriating but can be resolved with extra steps.
Instead, the deeper issue has to do with the interaction between CTAD and designated initializers. Consider this callsite:
auto v2 = Vector<int64_t>(Prams{
.size = 20,
.factory = DefaultFactoryFor<int64_t>,
});
This won't work. And the reason why is very upsetting.
When performing Class Template Argument Deduction, it first does an unevaluated invocation a synthesized overload set. That overload set, in this case, looks roughly like this:
Params();
Params(auto size);
Params(auto size, auto capacity);
Params(auto size, auto capacity, auto factory);
Then, when performing this invocation, it just uses the values of the arguments. It does not consider the field names.
So that means...
Params{.size = 10, .factory = DefaultFactoryFor<int64_t>}
... becomes ...
Params{10, DefaultFactory<int64_t>}
... which causes CTAD to select ...
Params(auto size, auto capacity);
Since the assumptions made about `auto capacity` are incompatible with the assumptions made about `.factory` arguments, this fails to compile!
I really wish that CTAD understood the field names when invoked via designated initializers.
I expected the default type values (`NotProvided`) and default member initializers (` = {}`) to work here. I thought it would unambiguously invoke the CTAD `Params(auto, auto, auto)` overload because all the arguments I did not spell (`.capacity`) would be "injected" into the callsite prior to type deduction. But that is not what happens.
If anyone knows a solution to this, I would be very happy.
https://redd.it/1te2yj1
@r_cpp
Windows vs MacOS
I’m new to programming with c++ and I’m currently going through introduction courses on Codecademy.
Is there a major difference with coding on Mac and coding on windows? Like big enough differences to specifically always use one over the other or is this kind of a no brainer question I should already know the answer to.
https://redd.it/1tdhz4f
@r_cpp
LWG 2839 inquiry
I’m working on a string library that wraps std::basic\_string and uses a “rvalue-aware” API pattern:
* const& overload returns a new string
* && overload tries to reuse the existing buffer and returns by value
The intended usage is this kind of chaining:
my_string s = "...";
s = std::move(s).trim();
s = std::move(s).to_lowercase();
I have many cases in which I found performance gains by defining a "create new object" version of a transformation alongside and inplace one and this pattern allows me to reuse method identifiers.
A simplified example looks like this:
struct my_string {
std::string data;
my_string trim() const& {
my_string result;
copy_trimmed_part_to(result); // determine subrange after trim and only copy that part
return result;
}
my_string trim() && {
trim_inplace(); // mutate the current object / reuse buffer
return std::move(*this); // return by value
}
// ...
my_string& operator=(my_string&&) = default;
};
My question is about [LWG 2839](https://cplusplus.github.io/LWG/issue2839), which talks about self-move-assignment.
At first glance, s = std::move(s).trim() feels like it might be related, because the && overload operates on s and then the result is assigned back into s. But the returned object is still a separate prvalue result, even if it reuses the original buffer internally.
So:
1. Is s = std::move(s).trim() actually covered by the self-move-assignment concerns from LWG 2839?
2. Or is LWG 2839 only relevant to direct cases like s = std::move(s)?
3. If the wrapper is built on top of std::basic\_string, is there any subtle standards issue with this API pattern itself?
4. Is the real risk instead overlap/aliasing in APIs like replace, insert, etc. when additional arguments may refer into the same string?
I’m interested both in the strict standards view and in whether this pattern is considered sound library design in practice.
https://redd.it/1tdalnh
@r_cpp
I built a graph database where everything is a fixed‑size node and storage is just an mmap‑ed file - looking for honest feedback
http://github.com/LincolnCox29/TrueGraphDataBase
https://redd.it/1td16em
@r_cpp
Manipulating URLs with Boost.URL
https://www.youtube.com/watch?v=ZK2TRfYciJ4
https://redd.it/1tcy9vm
@r_cpp
Reverse Dependency Ordering for C++ Includes
https://nukethebees.com/cpp-include-order/
https://redd.it/1tcx8yu
@r_cpp
Modules could have made the PIMPL idiom redundant - but they don't.
Consider the following class declaration:
export module A;
import B;
class A {
public:
A();
void foo();
private:
B m_b;
};
For a user of class A, the knowlege about the existence of B is wholly useless. You're forced to import the entire interface of B - interface that you're not even supposed to access - just to use A. The only thing that an importer of A needs to know is the size and alignment of B.
The typical way of solving this problem is to use Pointer to IMPLementation (PIMPL) - that is, expose only a pointer to a declared 'A::impl' struct, and define it in a source file implementing class A.
However, I thought that modules could make this workaround redundant, since the compiled A.gcm file could have simply have the size and alignment of B baked in. But it doesn't - you're forced to import B anyway. One can confirm this using GCC's -flang-info-module-cmi, here's the output when you compile the following file:
import A;
int main() {
A a;
}
In module imported at main.cpp:1:1:
A: note: reading CMI 'gcm.cache/A.gcm'
In module imported at A.cppm:3:1,
of module A, imported at main.cpp:1:
B: note: reading CMI 'gcm.cache/B.gcm'
But, I know, "What if B's functions (member or otherwise) is used in A's module interface unit!?". Sure, then you can import the entire B.gcm file. But I don't buy that the compiler does not know, or that it would be very hard to know, if B is exposed to the user during the compilation of A.gcm.
##But wait! There's more.
While the above is (probably) just an QoI issue, I have a bone to pick with how modules were standardized as well.
You see, there's something else that PIMPL buys us - not having to work around encapsulation. Anyone who has written non-trivial C++ programs before knows how annoying it can get to constantly switch back and forth between the source file and the header just to adjust some private functions. It's even worse when those functions take a private struct that you want to pass around - what's the point of encapsulation if you have to declare private implementation details anyway?
// Useless. Why do I have to put this in the header? Oh, right, "encapsulation"
namespace lib { class C; }
class A {
public:
A();
void foo();
private:
// Again, useless. The user doesn't care, and should not care, about any of this
struct Internal;
void private_func(Internal&);
Internal private_func2(lib::C, int, int);
// Friends only kind of help
friend void internal_func(A&, Internal&);
friend struct A_impl;
A_impl* impl;
};
The reason why C++ forces this onto you is because header files don't have any way of specifing the 'package' they belong to. The standard has no way of saying "this file can access A, but this cannot", because, to it, there is no difference between a user and an implementation file. It all just becomes a soup of unrelated symbols at the end.
But modules *can* do *do* differentiate between importers and implemetors, as such, I belive that **module implementation units should be able to access the private members of classes defined within that module**.
You can argue that this changes the semantics of C++ - and it does - it changes them for the better! There already are languages that successfully employ these semantics. Surely, if modules are all about 'modernizing C++' and 'getting rid of the cruft from headers', then we should embrace these modern solutions.
"But modules should be big packages, that's why we have partition units, and exposing all private members to every other class is a bad idea". NO! Partition units are terrible and you should not use them. Treat modules like source files - one class per module. The only reason why people *said* that is because modules cannot have circular dependencies, so the easiest way of working around that is to put everything into a single module. I'd argue
What's the highest C++ standard you can use with Boost.Graph today?
During our Boost Graph Modernization Workshop in Paris, one of the most frequent discussion points was the C++ standard version the Boost Graph Library should require. Modernization is intuitively in tension with C++14 😉
Some context worth knowing:
BGL currently supports C++14.
A lot of API modernization can be done without bumping the minimum.
Some modernization changes would land cleaner on a newer standard
We don't yet have a clear enough picture of our users' constraint space to inform our discussion about a potential baseline bump
We would deeply appreciate if you could find time to either answer this simple Github survey ( https://github.com/boostorg/graph/discussions/490 ), or to just drop a comment with your answer (C++14/17/20/23) in this reddit discussion !
Thank you for your time !
https://redd.it/1tc1v6x
@r_cpp
C++26: Standard library hardening
https://www.sandordargo.com/blog/2026/05/13/cpp26-library-hardening
https://redd.it/1tbqgnp
@r_cpp
I benchmarked duplicate detection strategies in C++ across every workload i could think of
https://dubeykartikay.com/posts/the-shape-of-duplicate-detection/
https://redd.it/1tbg319
@r_cpp
WG21 mailing for first feature meeting of C++29
https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2026/#mailing2026-05
https://redd.it/1tbalxf
@r_cpp
cost of enum-to-string: C++26 reflection vs the old ways
https://vittorioromeo.com/index/blog/refl_enum_to_string.html
https://redd.it/1tb89tx
@r_cpp
C++ Liquid Glass
https://kommodo.ai/i/R904ypjyy4G0Yhk7aCvf
I am working on bringing Liquid Glass to C++
The above Image is my current Progress please share your thoughts!
https://redd.it/1tayi05
@r_cpp
The Heap: Compile-Time Map and Compile-Time Mutable Variable with C++26 Reflection
https://stackoverflow.blog/2026/05/11/compile-time-map-and-compile-time-mutable-variable-with-c-26-reflection/
https://redd.it/1tadezp
@r_cpp
New C++ Conference Videos Released This Month - May 2026 (Updated To Include Videos Released 2026-05-04 - 2026-05-10)
**CppCon**
2026-05-04 - 2026-05-10
* Lightning Talk: The Type Safe Builder Pattern for C++ - John Stracke - [https://youtu.be/u5EG21amqlM](https://youtu.be/u5EG21amqlM)
* Lightning Talk: Back When ChatGpt Was Young And Stupid - Andrei Zissu - [https://youtu.be/q6-RSkQRmw0](https://youtu.be/q6-RSkQRmw0)
* Lightning Talk: Learning C++ Through Writing Coding Questions - Christopher DeGuzman - [https://youtu.be/FX63YwZ8OIs](https://youtu.be/FX63YwZ8OIs)
* Lightning Talk: Promote Modern C++ Usage With Coding Questions Part 2 - Zhenchao Lin - [https://youtu.be/uTCxKPaPsdM](https://youtu.be/uTCxKPaPsdM)
* Lightning Talk: std::move & Spirited Away: When Nameless Objects Walk the Spirited World - Siyu (Alice) Peng - [https://youtu.be/ffEOHVm7b4Y](https://youtu.be/ffEOHVm7b4Y)
2026-04-27 - 2026-05-03
* Lightning Talk: A Pragmatic Approach to C++: Designing, Organizing and Writing Maintainable Code - Oleg Rabaev - [https://youtu.be/re4Oy1IVj-s](https://youtu.be/re4Oy1IVj-s)
* Lightning Talk: Causal Inference for Code Writing AI - Matt K Robinson - [https://youtu.be/craQCfj73CI](https://youtu.be/craQCfj73CI)
* Lightning Talk: Cut the boilerplate with C++23 deducing\_this - Sarthak Sehgal - [https://youtu.be/o3vjUo2qXNg](https://youtu.be/o3vjUo2qXNg)
* Lightning Talk: The Lifecycle of This CMake Lightning Talk - Yannic Staudt - [https://youtu.be/3DqRIxXVfiI](https://youtu.be/3DqRIxXVfiI)
* Lightning Talk: Catching Performance Issues at Compile Time - Keith Stockdale - [https://youtu.be/YK8Kwj9okRk](https://youtu.be/YK8Kwj9okRk)
**C++Online**
2026-05-04 - 2026-05-10
* MayaFlux: Real-Time Audio-Graphics Coordination in C++20 (Coroutines, Lock-Free) - Ranjith Hegde - [https://youtu.be/\_qZvFNCYQ74](https://youtu.be/_qZvFNCYQ74)
* C++ for High Performance Web Application Backends - Uzochukwu Ochogu - [https://youtu.be/ulen8XhMeRA](https://youtu.be/ulen8XhMeRA)
2026-04-27 - 2026-05-03
* From 5000ns to 200ns - 5 Modern C++ Techniques Live Demo - Larry Ge - [https://youtu.be/9HqyiTWLENY](https://youtu.be/9HqyiTWLENY)
**Audio Developer Conference**
2026-05-04 - 2026-05-10
* Continuous QA Testing for Plugins Using AI and Python - Ryan Wardell - [https://youtu.be/w1hLmNPxOV4](https://youtu.be/w1hLmNPxOV4)
* Using Kotlin/Compose Multiplatform to Revive a Historic Multiplayer Online Drum Machine - How To Write An Audio App That Runs Almost Everywhere - Phil Burk - [https://youtu.be/8jA6Dg5iqfw](https://youtu.be/8jA6Dg5iqfw)
* Converting Source Separation Models to ONNX for Real Time Usage in DJ Software - Anmol Mishra - ADC 2025 - [https://youtu.be/CNs9EgMBocI](https://youtu.be/CNs9EgMBocI)
2026-04-27 - 2026-05-03
* From Paper to Plugin - A Guided Tour of Digital Filters - Ross Chisholm, Joel Ross & James Hallowell - ADC 2025 - [https://youtu.be/QlyWAfRUF30](https://youtu.be/QlyWAfRUF30)
* From Idea to Online Sale - The Full Journey of Building an Audio Plugin - Joaquin Saavedra - ADCx Gather 2025 - [https://youtu.be/mJoAArwAmkc](https://youtu.be/mJoAArwAmkc)
* Finding OSCar: Electronic and Software Secrets of a Classic Vintage Synth - Ben Supper - ADC 2025 - [https://youtu.be/NbIZEur3h7Q](https://youtu.be/NbIZEur3h7Q)
https://redd.it/1ta6i7f
@r_cpp