C++ - Reddit

Modern Loki: C++20 header-only port of Alexandrescu's classic, with 150 compiled & tested documentation examples

I rewrote Alexandrescu's Loki library from *Modern C++ Design* (2001) in C++20. Header-only, zero dependencies, full test suite.

What's different from the original:

* `typelist<Ts...>` using variadic templates instead of recursive `Typelist<H, T>`
* `abstract_factory` built on `std::tuple` instead of virtual multiple inheritance
* Threading policies using `std::mutex`/`std::shared_mutex`/`std::atomic`
* Visitors via `std::variant` \+ `overloaded` pattern alongside classic acyclic
* Concepts for policy constraints instead of SFINAE

The documentation is the part I'm most proud of: every single component has 10 real-world examples that are extracted from the Markdown by a Python script and compiled against MSVC as part of CI. If the docs lie, CI fails.

This is a teaching/reference library, not a "replace std::" library. If you're studying *Modern C++ Design* or teaching generic programming, this might be useful.

GitHub: [https://github.com/skillman1337/modern-loki](https://github.com/skillman1337/modern-loki) CI: MSVC 2022, GCC 13, Clang 17

https://redd.it/1s5lno0
@r_cpp

From Introductory to Advanced C++ - Learning Guidelines - Slobodan Dmitrovic - Meeting C++ 2025
https://www.youtube.com/watch?v=n8P11hDYWIs

https://redd.it/1s63dhz
@r_cpp

C++ feature for DI/DIP/OCP with the widest cross-language analogue

the abstract base class interface(ABCI) via pure virtual functions is perhaps the 1st. (apart from the C style function pointer). it is analogues to type, abstract in fortran, and dyn Trait in rust and ABC / Protocol in python

sometimes due to performance considerations in compiled languages, one needs to switch to the compile time alternatives. in cpp the most common one is template(used with concept) which is close to T: Trait in rust and interface in fortran.

Do you think ABCI and template+concept are the 1st and 2nd best in cpp? what else?

https://redd.it/1s6ikn8
@r_cpp

Report from the Croydon 2026 ISO C++ Committee meeting - mp-units
https://mpusz.github.io/mp-units/HEAD/blog/2026/03/28/report-from-the-croydon-2026-iso-c-committee-meeting/

https://redd.it/1s5y4tm
@r_cpp

Feeling Lost Between Low-Level Understanding and High-Level Coding (need advice)

Hi everyone,

I’m relatively new to high-level programming languages like C, C++, JavaScript, etc. Currently, I work as a programmer for PLCs and other controllers. In that space, coding is very low-level—we think in terms of bits, bytes, memory, and execution flow. Because of that, I have a solid understanding of what actually happens inside a controller when code runs (bit shifts, string operations, and so on).

Recently, with the rise of AI, I’ve started doing more high-level “vibe coding.” The challenge I’m facing is that I don’t fully understand what’s happening under the hood anymore.I can read and understand the code at a surface level, but when I try to break it down from an OS or system-level perspective, it feels abstract and heavily packaged.

Even when I try to write code at a surface level, I’m wired to dig into what’s happening underneath—otherwise, I start losing interest.



To address this, I’ve started learning C/C++ more rigorously from the ground up. However, it sometimes feels like the world is rapidly moving forward with new technologies while I’m going back to basics.

I wanted to check if I’m approaching this the right way and what I can do to improve my learning curve.

Would really appreciate any feedback ,advice or your experiences.

thanks

https://redd.it/1s6og1h
@r_cpp

Organizing C++ Module Sources
https://abuehl.github.io/2026/03/26/organizing-module-sources.html

https://redd.it/1s6nb7m
@r_cpp

C++20 Coroutines Optimization Opportunities from Compiler’s perspective
https://chuanqixu9.github.io/c++/2026/03/27/C++20-Coroutines-from-compiler-and-library-authors-perspective.en.html

https://redd.it/1s6miyt
@r_cpp

[CppCon] How C++ Finally Beats Rust at JSON Serialization - Daniel Lemire & Francisco Geiman Thiesen
https://www.youtube.com/watch?v=Mcgk3CxHYMs

https://redd.it/1s6jzk2
@r_cpp

Standard LLMs hallucinate on large C++ codebases. I built an open-source MCP server using tree-sitter to fix that.

I’ve been experimenting heavily with AI agents for legacy modernization, but I kept hitting a massive wall when dealing with C++.

If you just dump a bunch of intertwined C++ files into Claude or an open-source model, it loses context. It tries to refactor a function without knowing what upstream dependencies rely on it, or it gets tangled in circular references and breaks the build. Regex-based parsers also constantly miss the nuances of C++ macros and templates.

So, I built **LegacyGraph-MCP**, an open-source Model Context Protocol (MCP) server that turns "spaghetti code" into a queryable Knowledge Graph for AI Agents.

**How it works under the hood:** Instead of forcing the LLM to read raw text and guess relationships, the agent queries the structure.

1. **AST Parsing:** It uses `tree-sitter-cpp` for 100% accurate parsing (no regex hacks).
2. **Graph RAG:** It loads the codebase into a NetworkX directed graph.
3. **Agent Interaction:** The LLM uses MCP tools to ask specific questions like:
* *“Which functions call* `process_client()`\*?”\*
* *“Are there any circular dependencies here?”*
* *“What are the orphan functions?”*

**Features:**

* **Omni-Ingestion:** It can clone a GitHub repo, apply a patch, scan a local directory, or accept raw file uploads.
* **Hybrid Deployment:** You can run it locally (`stdio`) directly tied to your IDE/Claude Desktop, or deploy it to the cloud (`HTTP`/`SSE`) with ephemeral `/tmp/` clones.
* **Token-Safe Visuals:** It dynamically generates bounded Mermaid.js graphs inline so the LLM can visually map out the dependencies it is working on.

**The Ask:** The core graph logic is working well (I’ve got an end-to-end verifier passing 100% on test data), but I’m looking for feedback from people who work with *really* messy, real-world legacy code.

Specifically:

1. Does the cycle detection logic hold up against your worst circular dependencies?
2. Are there specific query tools (besides `get_callers`, `get_callees`, `detect_cycles`, etc.) that would make your life easier when using an AI coding assistant?

**Repository:** [LegacyGraph-MCP](https://github.com/RohitYadav34980/LegacyGraph-MCP)

*(If you are using Smithery or Claude Desktop, I included the quick-start configs in the README).*

What else can we build with this?
I am open to all ideas! Could we use this for automated test scaffolding for isolated subgraphs? Dead-code pruning pipelines? Vulnerability blast-radius analysis? Drop your ideas in the comments.

Whether you are a backend engineer optimizing graph algorithms, or someone pushing the limits of AI agents, there is a place for you here. Let’s build the ultimate open-source legacy modernization engine together.


Would love to hear your thoughts or see if this breaks on your weirdest legacy code!

https://redd.it/1rzws51
@r_cpp

How to understand modern C++ features in practice? Let's create a compiler! - Boguslaw Cyganek - Meeting C++ 2025
https://www.youtube.com/watch?v=_uuUw8N0qQ0

https://redd.it/1rzwojc
@r_cpp

Xoshiro256++ RNG with AVX2/512
https://github.com/bobjansen/Zorro

https://redd.it/1rzoo5h
@r_cpp

Kristian Ivarsson: Casual, an open-source SOA platform
https://youtu.be/2c-I7fzKPWY

https://redd.it/1rzn5p9
@r_cpp

Last C++26 meeting in Croydon is about to begin

Since not everyone is aware and confusion often arises regarding privated GitHub repos, let's inform people on Reddit this time: The last meeting for C++26 is about to begin. Some quick facts:

- The meeting lasts from 2026-03-23 (Mon morning) to 2026-03-28 (Sat afternoon). See also <https://isocpp.org/std/meetings-and-participation/upcoming-meetings>
- Until the meeting ends, <https://github.com/cplusplus/papers/> is private. The repos usually become visible again immediately after the meeting ends.
- The papers published during and after the meeting all go into the April mailing 2026-04-20. This includes the final working draft.
- All remaining NB (national body) comments should be resolved during this meeting. The working draft is then sent off to ISO for review and national bodies vote on the C++26 standard as a whole (yes/no/abstain).
- Any C++26 work takes priority, but once that is completed, time is spent on C++29 papers.

https://redd.it/1rzjovp
@r_cpp

Should assertions be used frequently in software development? And in what general scenarios are they typically applied?



https://redd.it/1rzfy9i
@r_cpp

Common Package Specification is Out the Gate
https://www.kitware.com/common-package-specification-is-out-the-gate/

https://redd.it/1rzdr6u
@r_cpp

A matter of style or is it?

Which one do you prefer (the constructor does some work and sets valid_):

class A {
public:
  explicit operator bool() const { return valid; }

private:
  bool valid_ = false;
}

or

class A {
public:
  bool is_valid() const { return valid; }

private:
  bool valid_ = false;
}

On the caller side:

A a{};
if (a) {
    // is valid
}

or

A a{}
if (a.is_valid()) {
    // is valid
}

https://redd.it/1rz8gq5
@r_cpp

Measuring stack headroom at runtime in C++
https://medium.com/@yair.lenga/how-much-stack-space-do-you-have-estimating-remaining-stack-in-c-on-linux-3c9513beabd8

https://redd.it/1rz7kl7
@r_cpp

C++/sys - A Standard Library Projection to Facilitate the Verification of Run-time Memory Safety

Hi all,

A while ago I was looking for a relevant C++ conference to demonstrate the capabilities of C++/sys. A pure C++ mechanism which offers a new approach to memory safety via debug-time verification.

My talk was accepted into C++Online 2026 which concluded a couple of weeks ago. The discussions were great, I received some really useful feedback (and the little 2D gather town was pretty fun!).

The slides are available here and the release video should appear on YouTube in the following weeks.

Excited to share the tech with the wider community. Much of it is discussed in the slides; some highlights:

Offers improvements over AddressSanitizer in terms of C++ error detection rate
Tracks access lifespan rather than blocks of data
Has contextual knowledge of C++ objects and containers so generally quite performant
100% detection rate for executed paths
Memory pinning and locking mechanism tracks dangling 'this' and references
Zero overhead in release builds
Compatible with any standard C++ compiler (from hosted C++98 running on MS-DOS to freestanding C++${LATEST} on Zephyr)
Doesn't interfere with C code/libraries. Just like Java, Rust, Python thin-bindings, these are treated as unchecked.

Some of the above sounds like magic but the core mechanism allowing for this is quite simple. Temporaries created by operator->, operator* and operator[\] lock memory for the lifetime of access and pointers are entirely prevented from dangling in a coarse-grained manner. Obviously this has an impact on what designs are possible with some discussion in the slides.

Link to the open-source (BSD 3-clause) reference implementation is here.

https://codeberg.org/kpedersen/sys\_public

https://research.thamessoftware.co.uk/sys

Very happy to discuss further. It has some rough areas but I personally love the tech and find it makes writing and testing C++ considerably more satisfying knowing that there is virtually zero chance of a memory error lurking in the tested branches.



https://redd.it/1rz3df4
@r_cpp

Looking at Unity finally made me understand the point of C++ coroutines · Mathieu Ropert
https://mropert.github.io/2026/03/20/unity_cpp_coroutines/

https://redd.it/1rz08da
@r_cpp

Draft idea: constructor member designators

I’ve been experimenting with a small idea to make constructor initializer lists a bit clearer and less error‑prone. The idea actually came from a dilemma I had when trying to settle on naming conventions for member variables. Prefixes like m_ or _name help avoid shadowing, but they also feel like a workaround for something the language could express more directly.

I wrote a short draft exploring “constructor member designators” - a `.member` syntax for constructor initialization.

https://github.com/richardcervinka/cpp-constructor-member-designators

This is just an experiment, but maybe someone will find it interesting.

https://redd.it/1ryyizp
@r_cpp