-
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
Boost.OpenMethod review starts on 28th of April
Dear /r/cpp community. The peer review of the proposed Boost.OpenMethod will start on 28th of April and continue until May 7th. OpenMethods implements open methods in C++. Those are "virtual functions" defined outside of classes. They allow avoiding god classes, and visitors and provide a solution to the Expression Problem, and the banana-gorilla-jungle problem. They also support multiple dispatch. This library implements most of Stroustrup's multimethods proposal, with some new features, like customization points and inter-operability with smart pointers. And despite all that open-method calls are fast - on par with native virtual functions.
You can find the source code of the library at https://github.com/jll63/Boost.OpenMethod/tree/master and read the documentation at https://jll63.github.io/Boost.OpenMethod/. The library is header-only and thus it is fairly easy to try it out. In addition, Christian Mazakas (of the C++ Alliance) has added the candidate library to his vcpkg repository (https://github.com/cmazakas/vcpkg-registry-test). You can also use the library on Compiler Explorer via `#include <https://jll63.github.io/Boost.OpenMethod/boost/openmethod.hpp>`.
As the library is not domain-specific, everyone is very welcome to contribute a review (or just an insightful comment, or a question) either by sending it to the Boost mailing list, or me personally (posting a response here counts as sending it to me personally). In your review please state whether you recommend to reject or accept the library into Boost, and whether you suggest any conditions for acceptance. Other questions you might want to answer in your review are:
* What is your evaluation of the design?
* What is your evaluation of the implementation?
* What is your evaluation of the documentation?
* What is your evaluation of the potential usefulness of the library?
* Did you try to use the library? With what compiler? Did you have any problems?
* How much effort did you put into your evaluation? A glance? A quick reading? In-depth study?
* Are you knowledgeable about the problems tackled by the library?
Thanks in advance for your time and effort!
https://redd.it/1k93soe
@r_cpp
Vibe Coding C++ - Jens Weller
https://www.youtube.com/watch?v=qriIlUOIM4o
https://redd.it/1k91z39
@r_cpp
How do you imagine c++ development in the next 30 years?
My Takes:
1) we will have figured tooling out. This means there will be a way that everyone uses for building, package management, lint, format ... maybe all packed into a single config file.
2) the standard wont add new features. I think there will come a saturation point from where we don't make the standard more complicated rather focus on simplicity and teachability.
https://redd.it/1k8p03y
@r_cpp
Refactoring is secretly inlining
https://brontosource.dev/blog/2025-04-26-refactoring-is-secretly-inlining
https://redd.it/1k8dxki
@r_cpp
How to design a unicode-capable string class?
Since C++ has rather "minimalistic" unicode support, I want to implement a unicode-capable string class by myself (and without the use of external libraries). However, I am a bit confused how to design such a class, specifically, how to store and encode the data.
To get started, I took a look at existing implementations, primarily the string class of C#. C# strings are UTF-16 encoded by default and this seems like a solid approach to me. However, I am concerned about implementing the index operator of the string class. I would like to return the true unicode code point from the index operator but this seems not possible as there is always the risk of hitting a surrogate character at a certain position. Also, there is no guarantee that there were no previous surrogate pairs in the string so direct indexing would possibly return a character at the wrong position. Theoretically, the index operator could first iterate through the string to detect previous surrogate pairs but this would blow the execution time of the function from O(1) to O(n) in the worst case. I could work around this problem by storing the data UTF-32 encoded. Since all code points can be represented directly, there would not be a problem with direct indexing. The downside is, that the string data will become very bloated.
That said, two general question arose to me:
When storing the data UTF-16 encoded, is hitting a surrogate character something I should be concerned about?
When storing the data UTF-32 encoded, is the large string size something I should be concerned about? I mean, memory is mostly not an issue nowadays.
I would like to hear your experiences and suggestions when it comes to handling unicode strings in C++. Also any tips for the implementation are appreciated.
https://redd.it/1k88o79
@r_cpp
How do you write Safe C++ Code ? Really Safe C++ code ?
Hi Guys,
A Biomedical Engineer here (but I am also a Computer Engineer), I have been learning C for Embedded Systems and also learning Rust (because it's currently the hot topic in MedTech for safety features), I am also exploring C++ on the side for Some passion projects like Low Level OS Systems, I was originally planning to use Rust but I thought to myself why not just use C++ like every other OS development?
Rust is still young and mature but is there a way to write Safe C++ code specially when every major news is all about Rust and Safety , and how C++ is dead,
I believe C++ will always be there and Rust will create more nuance because of its borrow checker and limited development environment for OS Development and reliance of LLVM.
So how do you write Safe C++ for low level stuff like Operating Systems and Networking Applications?
https://redd.it/1k81w5a
@r_cpp
Hi Guys, I made a little channel where I am focused on c++ and the application of it in small games and graphics; join me if you are interested.
sonofspades" rel="nofollow">https://www.youtube.com/@sonofspades
https://redd.it/1k7l3hz
@r_cpp
A taxonomy of C++ types
https://blog.knatten.org/2025/04/25/a-taxonomy-of-c-types/
https://redd.it/1k7izsr
@r_cpp
Any WebRTC Audio Processing Module separated repository?
Has anyone got a public repository for the WebRTC Audio Processing Module (APM) that can be cloned and built directly with CMake or Meson without all the GN build system complications?
I cloned the main webrtc repository, but just configuring it to build on windows seems like a nightmare.
I am trying to get a shared library (DLL) with updated AEC3, I was using this cross-platform/webrtc-audio-processing, which uses the Meson build system, but it appears to be based on the 5-year-old AEC2 module.
https://redd.it/1k7h1cw
@r_cpp
Microsoft revokes C++ extension from VS Code forks
https://www.theregister.com/2025/04/24/microsoft_vs_code_subtracts_cc_extension/
https://redd.it/1k7amhe
@r_cpp
libc++ sort patch by Deepmind: false statement or I'm missing something?
I'm looking at the code that has been changed in libc++ sort.h file back in 2022 by the Deepmind researchers who wrote the paper https://www.nature.com/articles/s41586-023-06004-9. In the commit they made they said "We are introducing branchless variants for sort3, sort4 and sort5. These sorting functions have been generated using Reinforcement Learning and aim to replace sort3, sort4 and sort5 variants for integral types."
I'm trying to take parts of the code of __algorithm.sort.h and compile it on Godbolt on the same architectures and with the same flags they used, however, despite the assembly code generated when sorting integral types is branchless and certainly more efficient than the one that was generated prior to the commit, it is not the one that AlphaDev found and it is also longer than the previous state of the art based on sorting networks.
To me it looks like they did not introduce the new optimal sort3, 4 and 5 functions in libc++ as there is no way to make c++ code compile into that.
Am I missing something or they actually stated something that is not true both on the commit and on the paper itself?
https://redd.it/1k768tt
@r_cpp
What is the state of modules in 2025?
Used it a couple of years ago and it wasn't that great, I coudnt even import standard libraries... I was wondering how it is now before starting a new project
https://redd.it/1k71uys
@r_cpp
Zero-cost C++ wrapper pattern for a ref-counted C handle
Hello, fellow C++ enthusiasts!
I want to create a 0-cost C++ wrapper for a ref-counted C handle without UB, but it doesn't seem possible. Below is as far as I can get (thanks https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p0593r6.html) :
// ---------------- C library ----------------
#ifdef __cplusplus
extern "C" {
#endif
struct ctrl_block { /* ref-count stuff */ };
struct soo {
char storageForCppWrapper; // Here what I paid at runtime (one byte + alignement) (let's label it #1)
/* real data lives here */
};
void useSoo(soo*);
void useConstSoo(const soo*);
struct shared_soo {
soo* data;
ctrl_block* block;
};
// returns {data, ref-count}
// data is allocated with malloc which create ton of implicit-lifetime type
shared_soo createSoo();
#ifdef __cplusplus
}
#endif
// -------------- C++ wrapper --------------
template<class T>
class SharedPtr {
public:
SharedPtr(T* d, ctrl_block* b) : data{ d }, block{ b } {}
T* operator->() { return data; }
// ref-count methods elided
private:
T* data;
ctrl_block* block;
};
// The size of alignement of Coo is 1, so it can be stored in storageForCppWrapper
class Coo {
public:
// This is the second issue, it exists and is public so that Coo has a trivial lifetime, but it shall never actually be used... (let's label it #2)
Coo() = default;
Coo(Coo&&) = delete;
Coo(const Coo&) = delete;
Coo& operator=(Coo&&) = delete;
Coo& operator=(const Coo&) = delete;
void use() { useSoo(get()); }
void use() const { useConstSoo(get()); }
static SharedPtr<Coo> create()
{
auto s = createSoo();
return { reinterpret_cast<Coo*>(s.data), s.block };
}
private:
soo* get() { return reinterpret_cast<soo*>(this); }
const soo* get() const { return reinterpret_cast<const soo*>(this); }
};
int main() {
auto coo = Coo::create();
coo->use(); // The syntaxic sugar I want for the user of my lib (let's label it #3)
return 0;
}
**Why not use the classic Pimpl?**
Because the ref-counting pushes the real data onto the heap while the Pimpl shell stays on the stack. A `SharedPtr<PimplSoo>` would then break the `SharedPtr` contract: should `get()` return the C++ wrapper (whose lifetime is now independent of the smart-pointer) or the raw C `soo` handle (which no longer matches the template parameter)? Either choice is wrong, so Pimpl just doesn’t fit here.
**Why not rely on “link-time aliasing”?**
The idea is to wrap the header in
# ifdef __cplusplus
\* C++ view of the type *\
# else
\* C view of the type *\
# endif
so the same symbol has two different definitions, one for C and one for C++. While this *usually* works, the Standard gives it no formal blessing (probably because it is ABI related). It blows past the One Definition Rule, disables meaningful type-checking, and rests entirely on unspecified layout-compatibility. In other words, it’s a stealth `cast` that works but carries no guarantees.
**Why not use** `std::start_lifetime_as` **?**
The call itself doesn’t read or write memory, but the Standard says that *starting* an object’s lifetime concurrently is undefined behaviour. In other words, it isn’t “zero-cost”: you must either guarantee single-threaded use or add synchronisation around the call. That extra coordination defeats the whole point of a free-standing, zero-overhead wrapper (unless I’ve missed something).
**Why this approach (I did not find an existing name for it so lets call it "reinterpret this")**
I am not sure, but this code seems fine from a standard point of view (even "#3"), isn't it ? Afaik, #3
C++26: more constexpr in the core language
https://www.sandordargo.com/blog/2025/04/23/cpp26-constexpr-language-changes
https://redd.it/1k6kh15
@r_cpp
How a 20 year old bug in GTA San Andreas surfaced in Windows 11 24H2
https://cookieplmonster.github.io/2025/04/23/gta-san-andreas-win11-24h2-bug/
https://redd.it/1k6g9gp
@r_cpp
Why std::println is so slow
clang libstdc++ (v14.2.1):
printf.cpp ( 245MiB/s)
cout.cpp ( 243MiB/s)
fmt.cpp ( 244MiB/s)
print.cpp ( 128MiB/s)
clang libc++ (v19.1.7):
printf.cpp ( 245MiB/s)
cout.cpp (92.6MiB/s)
fmt.cpp ( 242MiB/s)
print.cpp (60.8MiB/s)
./a.out World | pv --average-rate > /dev/null (best of 3 runs taken)-std=c++23 -O3 -s -flto -march=native-lfmt (prebuilt from archlinux repos) for fmt version.-stdlib=libc++ for libc++ version. (default is libstdc++)#include <cstdio>
int main(int argc, char* argv[])
{
if (argc < 2) return -1;
for (long long i=0 ; i < 10'000'000 ; ++i)
std::printf("Hello %s #%lld\n", argv[1], i);
}
#include <iostream>
int main(int argc, char* argv[])
{
if (argc < 2) return -1;
std::ios::sync_with_stdio(0);
for (long long i=0 ; i < 10'000'000 ; ++i)
std::cout << "Hello " << argv[1] << " #" << i << '\n';
}
#include <fmt/core.h>
int main(int argc, char* argv[])
{
if (argc < 2) return -1;
for (long long i=0 ; i < 10'000'000 ; ++i)
fmt::println("Hello {} #{}", argv[1], i);
}
#include <print>
int main(int argc, char* argv[])
{
if (argc < 2) return -1;
for (long long i=0 ; i < 10'000'000 ; ++i)
std::println("Hello {} #{}", argv[1], i);
}
libc++ and libstdc++ have to do shitty reimplementations of a perfectly working library, why not just use libfmt internally ?
Question about v tables?
I was solving old quizes but I've never come across a questino like this.
In the code below there are three class objects created during the lifetime of the executable: b, c, parameter. Which of the figures below best describes the objects in memory? Note that the objects are unnamed and unordered and the virtual table is not shown.
struct A {
virtual void f() = 0;
int x;
};
struct B : A {
virtual void f() override {}
};
struct C : B {
void f(B parameter) {} // copy constructed
};
int main() {
B b;
C c;
C & ref = c;
c.f( ref );
}
I cannot post actual pictures but here is thedifferent figures to pick from and I really don't understand. I guess the top to left means that B is an instance that contains an instance of A but other than that I really have no idea and would appreciate the help?
figure 1:
[B [A x\] x\] [B [A x\] x\] [C [B [A x\] x\] x\] [C [B [A x\] x\] x\]
figure 2:
[B [A x\] \] [B [A x\] \] [C [B [A x\] \] \] [C [B [A x\] \] \]
figure 3:
[B [A x\] x\] [C[B[A x\] x\] x\] [C[B[A x\] x\] x\]
figure 4:
[B [A x\]\] [B [A x\]\] [C [B [A x\]\]\]
figure 5:
[B [A x\]\] [C [B [A x\]\]\] [C [B [A x\]\]\]
https://redd.it/1k90uou
@r_cpp
Client gets stuck when handling concurrent requests to my HTTP server, even after receiving all the responses.
https://github.com/homocodian/http-server
https://redd.it/1k8j5fb
@r_cpp
import windows; ever coming?
So since yesterday three major compilers officially support C++20 import std, I am interested in using modules along with WinAPI, either via Microsoft official Windows SDK or MinGW. Is this even possible to port Windows SDK to C++20 modules? Some windows headers are heavy to parse. This is question rather to Microsoft but they don't respond to the community forum for months or even years.
https://redd.it/1k8dckr
@r_cpp
How difficult is it to integreate Rust in a C++ tool chain.
My project uses C++ and Objective-C++ at the moment. I target
\- MacOS / iOS via a ruby script that generates XCode projects
\- Android via NDK and CMake (version whatever the latest NDK provides)
\- Linux via CMake.
\- Windows via CMake but i have to go to write my own script that generates MSBuild to use the WinUI3 XAML Gui compiler.
How difficult will it be to integrate a few Rust files and libraries? Links to best practices?
Will it slow down the Edit-Compile-Run cycle a lot? This must be fast for me as i love experimental coding.
https://redd.it/1k82j8z
@r_cpp
What does this abusive code mean?
I've been handed someone's crappy code.
Inside a class definition, it has the following (other stuff has been deleted for clarity):
>class Selection {
>private:
>Selection(char *ss="OBJECT *"); /// <--- WTF is this???
>int type;
>String data;
>} ;
This code is old; it does not comply with C++ 8.5. Part of what I need to do is update it.
I know that non-ancient versions of C do not accept assignment of a char* to a string literal. That's not my concern. My concern is what exactly does this assignment inside the argument section of a constructor definition mean? I would like to update this to at least C++11 in a memory safe way. note also that ss is not a field of the Selection class. Which is even more annoying.
https://redd.it/1k80a84
@r_cpp
GCC 15 Released 🎉
🎉Congratulations to the GCC team!
🎆🎇🔥💥 🤩 🎊 🥳 🤟 🍻 🥂 👍
Release Notes
GNU Git Branch and Tag (quite slow)
Github mirror
https://redd.it/1k7lmmn
@r_cpp
New C++ features in GCC 15
https://developers.redhat.com/articles/2025/04/24/new-c-features-gcc-15
https://redd.it/1k7iafq
@r_cpp
Tools for planning and structuring large C++ projects?
So we have a system with thousands of classes that is about to be ported from Smalltalk to C++ for multiple reasons (better OS integration, performance and interoperability). While we can use a fantastic in-house tool to automate most of the translation at the class/method level, there is considerable effort involved in structuring the system at the file level. Deciding about separation into modules, what goes into headers, what goes into code, dealing with cyclic dependencies, etc.
Smalltalk is compiled and re-linked at the method/symbol level in real time (while the app is running), so there is no such "file structure" that could be ported. It needs to be planned from scratch.
Are there any tools that could help with planning for this task? Like, I give it a graph of class names and classify their dependencies as strong (requires complete definition) or weak (forward declaration is enough), and whether they are templates, polymorphic, etc. And then the tool outlines a file structure and inclusion graph?
https://redd.it/1k7ezwl
@r_cpp
ERR LNK: 1104: Cannot open "libcpmtd.lib"
Hi,
I'm making a project in VS2022 and so I linked two libraries, and specified library path and yes, they exist, but their pdb in debug mode is not found although it is included in their path, so I'm not sure. I keep getting this error and I tried more than 10 solutions and non of them worked I'm not even joking. Yes, the libraries I linked match my program CRT. Yes, the libcp matches my program CRT. I never had this issue before.
https://redd.it/1k76lya
@r_cpp
I did a writeup on how I use asynchronous networking to span multiple APIs and link the data together all on a single thread
https://www.kulve.org/blog/async_deep_dive
https://redd.it/1k71jnx
@r_cpp
always works from an implementation point of view, even if I get ride of "#1" and mark "#2" as deleted (even with `-fsanitize=undefined`). Moreover, it doesn't restrict the development of the private implementation more than a pimpl and get ride of a pointer indirection. Last but not least, it can even be improved a bit if there is a guarantee that the size of `soo` will never change by inverting the storage, storing \`soo\` in `Coo` (and thus losing 1 byte of overhead) (but that's not the point here).
**Why is this a problem?**
For everyday C++ work it usually isn’t—most developers will just `reinterpret_cast` and move on, and in practice that’s fine. In safety-critical, out-of-context code, however, we have to treat the C++ Standard as a hard contract with any certified compiler. Anything that leans on *undefined behaviour*, no matter how convenient, is off-limits. (Maybe I’m over-thinking strict Standard conformance—even for a safety-critical scenario).
So the real question is: what is the best way to implement a zero-overhead C++ wrapper around a ref-counted C handle in a reliable manner?
Thanks in advance for any insights, corrections, or war stories you can share. Have a great day!
Tiny troll footnote: in Rust I could just slap `#[repr(C)] struct soo;` and be done 🦀😉.
https://redd.it/1k70puk
@r_cpp
I wanna know how this code compiles and runs. (constexpr, C++23)
Does std::vector<int> a allocated, and filled (std::iota) during compile time or run time? (C++23)
constexpr int n = 1e6; // 1'000'000
vector<int> a(n);
iota(a.begin(), a.end(), 1);
The above code is snippet of my solution to one of the problems on CodeForces.
https://redd.it/1k6w0dc
@r_cpp
Living in the future: Using C++26 at work
http://herbsutter.com/2025/04/23/living-in-the-future-using-c26-at-work/
https://redd.it/1k6jj54
@r_cpp
Declarative GUI toolkit - Slint 1.11 adds Color Pickers to Live-Preview 🚀
https://slint.dev/blog/slint-1.11-released
https://redd.it/1k5ws6o
@r_cpp