-
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
Preventing Integer Overflow in Physical Computations - mp-units
https://mpusz.github.io/mp-units/HEAD/blog/2026/04/11/preventing-integer-overflow-in-physical-computations/
https://redd.it/1sqkrhd
@r_cpp
I am new to C++, is it just me or is the checklist kinda crazy? How often do you encounter these or plan on making use of them like the newer C++26 features like contracts? Looking for more experienced dev opinions...
I know Python and have been binging C++ for a couple of days now from scratch. C++ feels like a language where you gradually discover a huge checklist of "STATE YOUR INTENT" due to years of probably layering on things to shore up its weaknesses of memory/type safety etc. Like I get it, it's how C++ was designed for things to be explicit and it's like the English language where you don't need to know every word and in this case, feature, but every line of code makes me feel I'm asking a gajillion questions.
So far I have jotted down some stuff that took me awhile to digest...
* const
* constexpr
* [[nodiscard]]
* std::expected
* delete("reason")
* smart pointers
* zero-initialization curly brackets
* structured bindings
* assert
* static assert
* contracts
So I guess I'm not very familiar with the ecosystem or ever worked with other C++ code. Like is this good or bad? I would think it's very safe but do and should people code actually C++ like this? I don't have a frame of reference to relate to and I don't know if the C++ community is going to jump on things like C++26's contracts or reject it. What's the current attitude? If you were a teammate, would you love or hate to see something like this?
[[nodiscard]] constexpr std::expected<int, Error> GetHP(const std::unique_ptr<Player>& player)
{
assert(player);
if (!player) return std::unexpected(Error::NullPlayer);
const auto [hp, alive] = std::pair{player->hp, player->hp > 0};
static_assert(sizeof(int) == 4);
return alive ? hp : 0;
}
https://redd.it/1sqhobx
@r_cpp
Freeing up the syntax for a module partition implementation unit
https://www.reddit.com/r/cpp/comments/1scfoh9/comment/oefg9gm/
https://redd.it/1sqduld
@r_cpp
I built a calm, readable system monitor for Linux (Qt6, C++20, open source)
Most Linux system monitors end up in one of two places: they feel ancient and cramped, or they show everything at once and become visual noise. I wanted something in between, genuinely useful but still pleasant to look at for more than ten seconds. So I built archvital.
It has a compact Overview page for the numbers that matter most, plus dedicated pages for CPU, GPU, Memory, Disk, Network, Tasks, and a Diagnostics page for common health checks. There is a Settings page for theme colors and section visibility, and preferences are saved through QSettings so the app remembers your layout between sessions.
The whole thing is built on Qt6 and C++20 with custom sidebar, card, sparkline, and bar components. No extra widget library beyond Qt itself.
The project is already daily driveable but still actively evolving. Screenshots are in the repo. If you try it and something looks wrong or reads oddly, that is exactly the kind of feedback I am looking for.
github.com/T9Tuco/archvital
https://redd.it/1sq6siu
@r_cpp
Adding Stack Traces to All C++ Exceptions
https://werwolv.net/posts/cpp_exception_stacktraces/
https://redd.it/1spnzjn
@r_cpp
Live Coding in C++ Is Difficult But Not Impossible
https://youtu.be/Tb8Ni1jdcGI?t=989
https://redd.it/1spjik3
@r_cpp
Opinions on Introducing C++: The Easy Way to Start Learning Modern C++ by Frances Buontempo
What do you guys think about the book Introducing C++: The Easy Way to Start Learning Modern C++ by Frances Buontempo i was considering to buy it because i want to learn c++ and i already have some experiences coding in other languages it seems like a sort of successor to accellerated c++
https://redd.it/1sp3epy
@r_cpp
A simplified model of Fil-C
https://www.corsix.org/content/simplified-model-of-fil-c
https://redd.it/1som5pr
@r_cpp
Built an AI overlay that disappears on screen share — one Win32 API call, C++, and a week of evenings
Built this after getting frustrated during technical interviews — an AI assistant that's literally invisible on screen share
I kept wondering why there wasn't a clean way to have a personal reference window open during video calls without it being visible on screen.
Then I found out about SetWindowDisplayAffinity — a Windows API that lets you exclude a window from all capture. OBS, Zoom, Teams, Google Meet — none of them pick it up. The window exists on your screen, nowhere else.
Spent a week building an overlay on top of it. Floating AI assistant. Only you can see it. That's the whole thing.
Shipped it at www.unviewable.online.
For anyone curious about the tech — it's C++ with CMake, the magic is literally one Win32 API call. Windows has had this since Windows 10 2004 and barely anyone talks about it. Wild.
https://redd.it/1sodzjg
@r_cpp
Built a Preemptive Task Scheduler in C++ from scratch: Performance comparison across Windows, Linux, and PREEMPT_RT kernel.
https://prejudice.tistory.com/45
https://redd.it/1so5213
@r_cpp
Online talk on building a C++ based custom language and lexer internals
Developers from PVS-Studio are continuing their series of talks about creating a custom programming language. They will explain what the lexer is, what it consists of, and how to work with it.
The talk series as a whole is for devs who want to start understanding how compilers work under the hood. Throughout the series, their C++ architect demonstrates the practical application of each programming language component.
If you're interested, I leave the link here.
https://redd.it/1so08nx
@r_cpp
C++20 Modules: The Tooling Gap
https://ignition.github.io/posts/cpp20-modules-the-tooling-gap/
https://redd.it/1snx6r8
@r_cpp
Question to Module Users: How Do You Use Partitions?
Quick question for those who currently use modules with partitions.
That is, for a module like the one below (our file Core/\_Module.ixx):
export module Core;
export import :Attach;
export import :Base;
export import :Container;
export import :Diagram;
export import :Interfaces;
export import :Transaction;
export import :View;
How did you implement your code?
What we did:
We have done it as I've described in my blog posting "How a Module Should Look", which is for example for our file Core/Transaction/FinalizerDock.cpp:
module Core;
import :Transaction;
...
which contains function definitions for declarations in the partition Core/Transaction/Transaction.ixx:
export module Core:Transaction;
...
Please tell me what you did. I'm really curious.
Thanks in advance for the responses!
https://redd.it/1snrk4q
@r_cpp
SFML 3.1 is released
https://github.com/SFML/SFML/releases/tag/3.1.0
https://redd.it/1sndilj
@r_cpp
Achieving 56.5 ns cross-language IPC latency: Defeating false sharing and bypassing the kernel.
Hi,
I recently open-sourced Tachyon, a low-latency shared-memory IPC library I’ve been working on. The goal was to reach RAM-speed communication between processes (C++, Rust, Python, etc.) without any serialization overhead or kernel involvement on the hot path.
I managed to hit a p50 round-trip time of 56.5 ns (for 32-byte payloads) and a throughput of \~13M RTT/sec on an i7-12650H, which is about 150x faster than ZeroMQ inproc.
Here are a few architectural choices I made to achieve this, which I thought might interest this sub:
Strict SPSC & No CAS: I went with a strict Single-Producer Single-Consumer topology. There are no compare-and-swap loops on the hot path. acquire_tx and acquire_rx are just a load, a mask, and a branch using memory_order_acquire/release.
Hardware Sympathy: Every control structure (message headers, atomic indices) is padded to 64-byte or 128-byte boundaries. False sharing between the producer and consumer cache lines is structurally impossible.
Hybrid Wait Strategy: The consumer spins for a bounded threshold (cpu_relax()), then sleeps via SYS_futex (Linux) or __ulock_wait (macOS).
Zero-Copy: The hot path is entirely in the memfd shared memory segment after an initial Unix Domain Socket handshake.
The core is C++23 (compiled with GCC 14+/Clang 17+), and it currently has bindings for 6 other languages.
Repository: https://github.com/riyaneel/Tachyon
I’d love to get some feedback from the C++ community on the architecture, especially regarding the memory model implementation and the hybrid futex spin-wait strategy.
Thanks!
https://redd.it/1sn8a1y
@r_cpp
Avoiding per-cell std::string allocation in a vectorized filter
Writing a small columnar query engine and hit a string-copy trap in the filter operator. The fix turned out to be
measurable so I thought I'd share.
Naive version: output chunk built cell-by-cell.
for (idx_t i = 0; i < input.size(); i++) {
if (!matches[i]) continue;
for (idx_t c = 0; c < num_cols; c++)
result.SetValue(c, out, input.GetValue(c, i));
out++;
}
GetValue/SetValue go through a tagged Value type, and for VARCHAR they each allocate a fresh std::string. 1Muint32_t sel[] of matching row indices, then per column copy with the typed pointer.auto *s = src.GetData<int64_t>();
auto *d = dst.GetData<int64_t>();
for (idx_t i = 0; i < n; i++) d[i] = s[sel[i]];
string_t is a 16-byte type, inline for short strings, aVectorStringBuffer) is already owned via shared_ptr<VectorBuffer>. Fix is a setter that makes dstauto *s = src.GetData<string_t>();
auto *d = dst.GetData<string_t>();
for (idx_t i = 0; i < n; i++) d[i] = s[sel[i]];
dst.SetAuxiliaryPtr(src.GetAuxiliaryPtr()); // dst keeps src's heap alive
WHERE ... GROUP BY region query on 1M rows went from 894 ms to ~150 ms. Roughly 100 ms of that was this changeshared_ptr<Buffer>
Software taketh away faster than hardware giveth: Why C++ programmers keep growing fast despite competition, safety, and AI
https://herbsutter.com/2025/12/30/software-taketh-away-faster-than-hardware-giveth-why-c-programmers-keep-growing-fast-despite-competition-safety-and-ai/
https://redd.it/1sqgbaq
@r_cpp
SIMD IPv6 lookup vs Patricia trie: surprising real-world results
I’ve been working on a C++ implementation of a SIMD-accelerated IPv6 longest-prefix-match (LPM) structure based on the PlanB paper (linearized B+-tree + AVX-512).
On synthetic workloads, the results were as expected:
\~20× faster than a naive Patricia trie.
But when I switched to a real BGP table (RIPE RIS rrc00, \~254K IPv6 prefixes), I got a surprising result:
A simple Patricia trie can actually match or even outperform the SIMD-based tree.
Numbers (single core, Ice Lake laptop):
\- SIMD tree: \~65–137 MLPS
\- Patricia: \~95 MLPS median
The reason seems to be cache locality and early exits:
\- Patricia often resolves lookups after just a few pointer hops in hot regions of the address space
\- The SIMD tree always pays a fixed traversal cost (depth \~7)
So even though the SIMD approach is more “theoretically efficient”, real-world prefix distribution and access patterns change the outcome quite a bit.
I’m curious if others have observed similar effects in routing / packet processing systems, or when comparing structures like PopTrie / CP-Trie.
Repo (MIT, includes benchmarks + real BGP reproduction):
https://github.com/esutcu/planb-lpm
https://redd.it/1sqe08e
@r_cpp
A virtual pointer pattern for dynamic resolution in C++ — years in production
I've been working on Olex2, a crystallography software package, for over 20 years. At some point I needed pointers whose target wasn't a fixed address but a runtime decision — "whatever is currently the active object of this type."
The result was olx_vptr — a virtual pointer where resolution is delegated to a user-defined get_ptr():
https://github.com/pcxod/olex2/blob/master/sdl/olxvptr.h
The calling code uses natural pointer syntax and knows nothing about how resolution happens. A concrete use looks like this:
struct VPtr : public olx_virtual_ptr<TXFile> {
virtual IOlxObject *get_ptr() const;
};
olx_vptr<TXFile> thip(new VPtr());
lib->Register(
new TFunction<TXFile>(thip, &TXFile::LibGetFormula, "GetFormula", .....
(https://github.com/pcxod/olex2/blob/master/xlib/xfiles.cpp#L1427)
Single virtual dispatch, fully type-safe, open to any resolution strategy.
I'm surprised this pattern never made it into the standard or common literature. Has anyone seen something similar? Would there be interest in a more formal writeup?
https://redd.it/1spvxx6
@r_cpp
mini project
I built a small to-do List project in C++
I'd appreciate if you can take a quick look and give feedback on:
\>File structure
\>Code design
\>Any bad practices
\> the name must be one word like (ex_ex_ex) and i can't solve that
GitHub link: to-do\_list\_cpp/to\_do\_list.cpp at main · TheGreat-A7A/to-do\_list\_cpp
https://redd.it/1spmp6g
@r_cpp
Using Internal Partitions
https://abuehl.github.io/2026/04/18/using-internal-partitions.html
https://redd.it/1spe1lu
@r_cpp
Next week: Interview with Guy Davidson at Meeting C++ online
https://www.meetup.com/de-de/meeting-cpp-online/events/314162009
https://redd.it/1sozbmk
@r_cpp
C++26 2026-04 Update
https://en.cppreference.com/cpp/compiler_support/26
https://redd.it/1sojtkm
@r_cpp
cppreference is back up! but overloaded
I just clicked a link that wasn’t cached and noticed very long loading time. Eventually the page loaded, and I noticed the font was different. After Herb’s post, I was excited and noticed the homepage notice declared the site newly operational again! However I am experiencing a significant number of 5xx errors.
https://redd.it/1so7kx8
@r_cpp
build2 0.18.1 released, adds package manager Fetch Cache, JSON Compilation Database, and official binary packages
https://build2.org/release/0.18.0.xhtml
https://redd.it/1so1igj
@r_cpp
HPX Tutorials: Performance analysis with Traveller
https://www.youtube.com/watch?v=xN5BM7FzDsI
https://redd.it/1snyotu
@r_cpp
Documenting my Chess Engine Journey So Far!
Just thought I'd pop this here. Am writing a Chess Engine in C++ and am blogging all the trials, tribulations and optimizations in what I'm hoping is a semi-humorous and entertaining way.
Would love any feedback you might have and also would love feedback on the code which is available towards the top!
https://olly-evans.github.io/chess/
https://redd.it/1snwal6
@r_cpp
I built a tool for C++ devs using Neovim that shows field offsets, padding, alignment, and total struct/class size from clang. It also handles STL types and templates.
https://github.com/J-Cowsert/classlayout.nvim
https://redd.it/1snn58i
@r_cpp
GUI toolkit Slint 1.16 released with keyboard shortcuts, Markdown rendering, and multi-touch pinch and rotate
https://slint.dev/blog/slint-1.16-released
https://redd.it/1snc6ow
@r_cpp
Special meetup with Bjarne Stroustrup in Florence
Hi everyone!
I am organizing a special meetup with Bjarne Stroustrup in Florence on Saturday, May 9!
Schedule:
09:30 – Doors open
10:00 – Welcome message
10:15 – Technical session: “Concept-based Generic Programming”
11:45 – Short break
12:00 – Live AMA with Bjarne Stroustrup
13:00 – Closing
The event will take place at the University of Florence (Novoli Campus) and is organized by the Italian C++ Community, the University of Florence, and the University of Pisa.
For developers traveling from abroad, this is also a great excuse to visit Florence, while connecting with the Italian C++ community.
Free registration and details:
https://italiancpp-fi26.eventbrite.it/
Looking forward to seeing you there!
https://redd.it/1sn2g4d
@r_cpp