C++26: what is “template for”? Learning with simple example.
https://techfortalk.co.uk/2026/07/20/c26-what-is-template-for/

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

Pure Virtual C++ 2026: MSVC, are we there yet? Status of C++23 and C++26 features
https://youtu.be/ZHsQ58ROEhI?si=WMidU5yfCGH3958U

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

Good web site/GitHub repo for practice

Hi everyone,

I'm looking for one good web site with coding exercises for practice c++.

Ofc I know that Leetcode/Codeforces is good but I'm looking for web sites where I can practice all topics of c++ from OOP to concurrent and parallel programming.

Good thing will be if you know for some sites where you get code snippet and then need to predict output/what is error.

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

Is there something like a VM to wrap tools such as LLVM IRBuilder?

I'm working on a lightweight embedded scripting language for C++ applications. This is intended for modest extensions to the applications themselves, such as adding context-menu options to GUI controls (scripts are handlers for when the option is activated); parsers for loading data in custom serialization formats (scripts might be pairs of regex rules with match callbacks); or statistical analyses for data sets. The language has a VM which aims to be almost trivial, or at least have a minimal working core -- mostly instructions to build up a parameter list and call C++ code via function pointers. One of my goals is to minimize the distinction between calling C++ functions from a host application versus methods that implement basic language elements, like declaring/initializing variables, managing lexical scopes and variable lifetimes, and branching/loop blocks. For instance, instead of "jump" instructions if/else could be implemented as a C++ function whose second argument is an object encapsulating a code block.

My question is as follows: with this setup I am researching the feasibility of transpiling to C++ files rather than executing scripts immediately. For the basic language I seek to minimize heavy dependencies like LLVM (leaning more toward a much smaller infrastructure, like LuaVM). But I would accept external dependencies for optional extensions.

Generating C++ code directly via something like std::stringstream seems pretty awkward. I've read about Jank's IR from which C++ code is produced (and then, I believe, compiled immediately via Clang). Perhaps Gabriel dos Reis's IPR could be used to similar effect. Instead of compiling \*to\* IR, generate IR and decompile to C++ source code.

But since my compiler pipeline is designed to emit VM code, I'm hoping some tools might exist for which IR is more akin to instructions in some special-purpose bytecode format. Functionally, I'm envisioning something like LLVM IRBuilder, where code-generation is decomposed into lots of small actions (add some token to an argument list, open/close some code block, etc.). Even just a wrapper around IRBuilder might work. But what I hope to find is a sort of DSL where various IRBuilder methods (or the equivalent) could be written in sequence, one-line-per-instruction style. One thing confusing me is that online discussions about .ll files "decompiling" to C++ aren't clear as to whether the goal is generating IRBuilder code that would produce the equivalent .ll code, or conversely reconstructing the actual C++ originally written. Substantially though I'm not sure how much it matters. Here's what AI spits out as a simple IRBuilder example:

Type* Int32Ty = Type::getInt32Ty(Context);
std::vector<Type*> ParamTypes = {Int32Ty, Int32Ty};
FunctionType *FuncType = FunctionType::get(Int32Ty, ParamTypes, false);
Function *AddFunc = Function::Create(FuncType, Function::ExternalLinkage, "add", OwnerModule.get());
Function::arg_iterator Args = AddFunc->arg_begin();
Value* ArgA = Args++;
ArgA->setName("a");
Value* ArgB = Args;
ArgB->setName("b");

I could certainly envision an interface like this to produce equivalent C++ code:

int32_t add(int32_t a, int32_t b)

and so forth. But it would be excellent if the IRBuilder code could be replaced by something more VM-like:

init-arg-list
add-param-type @Int32Ty
add-param-type @Int32Ty
add-return-type @Int32Ty
reset-arg-cursor
set-arg-name "a"
inc-arg-cursor
set-arg-name "b"
inc-arg-cursor
set-proc-name "add"
write-function-signature

or something like that (imagining a "@" sigil on type names). The point is that the above lines might be pretty close to VM code intended to call the "add" function at runtime, so you could use the same compiler toolchain for multiple steps before generating one kind of code for runtime scripts and a different VM flavor for producing C++ source files.

I don't think there's any

LLVM target that works this way. But perhaps some third-party library?

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

boost::int128 review starts today (July 22 - July 31)

Announced officially on the [Boost mailing list](https://lists.boost.org/archives/list/[email protected]/thread/GLZALH3WRHSICP6ZYOFDOPWUQTJUKOM5/)

**Introduction**

The formal review of Matt Borland's `boost::int128` for inclusion in the Boost libraries, starts today.

Int128 is a portable C++14 implementation of signed and unsigned 128-bit integers. It has no dependencies, is header-only, and can be consumed as a module in C++20. It serves as a practical solution to the partial (resp. absent) support of 128-bit integers by gcc/clang (resp. msvc), and as a lightweight alternative to heavier projects.

You can find the library and its documentation here:
\- [https://github.com/cppalliance/int128/tree/boost\_review](https://github.com/cppalliance/int128/tree/boost_review)
\- [https://develop.int128.cpp.al/overview.html](https://develop.int128.cpp.al/overview.html)
\- Compiler Explorer: [https://godbolt.org/z/5aM6K9b4r](https://godbolt.org/z/5aM6K9b4r)

Although possibly not faithful to Matt's implementation, this CE link will be handy if you are in a rush but want to play with the library.

Anyone is welcome to post a review and/or take part in subsequent discussions in the mailing list.

**Review guidelines**

Please provide feedback on the following general topics:

* 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 which compiler(s)? 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 problem domain?

Ensure to explicitly include with your review: ACCEPT, REJECT, or CONDITIONAL ACCEPT (with acceptance conditions).

Thank you for your time making our OSS ecosystem better. Happy to start the discussions!

Arnaud Becheler (Review Manager)

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

I implemented Smart Pointers from scratch in C++ (UniquePtr, SharedPtr & WeakPtr)

I’ve been trying to spend more time building things from scratch instead of just reading about them.
My latest project was implementing UniquePtr, SharedPtr, and WeakPtr in C++ with reference counting.
It ended up being much more interesting than I expected. Small mistakes in reference counting quickly turned into bugs like memory leaks, double-free, and use-after-free, which made me appreciate the standard library implementation even more.
Current status:
UniquePtr
SharedPtr
WeakPtr
Reference counting
18/18 test cases passing
Repository:
https://github.com/574-jayeshSh/smart-pointer-library
I’d love to hear feedback from people who’ve implemented something similar or suggestions on what I should improve next.

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

Pure Virtual C++ Videos Are Now Available
https://devblogs.microsoft.com/cppblog/pure-virtual-c-2026-is-a-wrap/

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

Project A backend-agnostic C++17 document intelligence pipeline with measurable OCR, layout and table stages

I have been working on an early-stage open-source document intelligence engine in C++17.



The goal is not to own every OCR or layout model. The core keeps typed pipeline boundaries and normalizes PDF text, OCR, layout blocks, tables, reading order, coordinates, confidence and provenance into a stable document model.



Current components include:



\- PDFium rendering and native text

\- PaddleOCR ONNX and optional Tesseract

\- RF-DETR DocLayNet and Paddle PP-DocLayoutV3

\- Table Transformer detection and structure recognition

\- JSON/Markdown/HTML output

\- small public regression datasets

\- an optional FastAPI/Redis Streams/persistent C++ Worker/React inspection platform



It is still an alpha. The current small benchmark subsets are regression checks, not production accuracy claims.



I am looking for contributors interested in C++ architecture, ONNX session reuse, OCR/CV evaluation, Redis Streams recovery, reading order, or Web-based bounding-box diagnostics.



Repository:

https://github.com/ChNanAn/technical-doc-parser

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

Fil-C: Garbage In, Memory Safety Out! - Filip Pizlo | SSW 2026
https://www.youtube.com/watch?v=5F-2Y1LPRek

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

The portable way to extract date and time from a file's mtime in C++
https://sandordargo.com/blog/2026/07/22/extracting-datetime-from-mtime

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

State of "moved-from" objects

Hi, I recently decided to try writing a C++ blog.

I often see the popular claim that moved-from objects are in a "valid but otherwise unspecified state", but I don't think that statement is entirely precise, and my blog post is about that.
I would really appreciate any feedback!

Article: https://www.laminowany.dev/p/the-state-of-moved-from-objects-in-c/

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

Binding int from variant to reference in Foo.

Hello guys, my friend had a problem where he couldn't bind an int to int reference in Foo struct held in variant:

struct Foo {
int &abc;
};

std::variant<Foo, std::string> v;

// You can't!
v = Foo {
.abc = ...
}

So I developed a way to do that, it's pretty simple:

#include <cstdint>
#include <functional>
#include <iostream>
#include <string>
#include <variant>
#include <meta>
#include <ranges>

struct __attribute__((packed)) Foo {
int& abc;

~Foo() {
static_assert(sizeof(void*) == 8, "Use modern CPU.");

static_assert([]() consteval {
auto members = std::meta::nonstatic_data_members_of(
^^Foo,
std::meta::access_context::current()
);

for (auto member : members) {
auto type_info = std::meta::type_of(member);
std::size_t layout_size = std::meta::is_reference_type(type_info)
? sizeof(void*)
: std::meta::size_of(type_info);

if (layout_size != 8) {
return false;
}
}
return true;
}(), "All non-static data members of Foo must occupy 8 bytes in layout!");

if (reinterpret_cast<uintptr_t>(&abc) & 0x1) {
delete reinterpret_cast<int*>(reinterpret_cast<uintptr_t>(&abc) &
~uintptr_t(0x1));
}
}
};

int main(void) {
std::variant<int, Foo> v;
v.emplace<0>(420);
v.emplace<1>(([&]() -> int& {
int* x = new int;
*x = std::get<0>(v);
x = reinterpret_cast<int*>(reinterpret_cast<uintptr_t>(x) | 0x1);
return *x;
})());
std::cout << *reinterpret_cast<int*>(
reinterpret_cast<uintptr_t>(&std::get<1>(v).abc) &
~uintptr_t(0x1))
<< std::endl;
return 0;
}

[https://godbolt.org/z/91rcbEdG5](https://godbolt.org/z/91rcbEdG5)

It's also memory safe.

Cheers.

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

Some practical refactoring of bloated generated code
https://pvs-studio.com/en/blog/posts/cpp/1395/

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

mp-units: a design for logarithmic quantities and units (dB, dBm, Np, pH). We believe it is novel, and we need domain experts to tell us where we are wrong before we implement it
https://mpusz.github.io/mp-units/latest/blog/2026/07/24/introducing-logarithmic-quantities-and-units/

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

Switching from Java to C++

Having grasped of Java SE I cannot completely write mechanical sympathy code from it. Can you suggest how should I start C++ language? I want to get ready with syntax first is there any critics or guide is so when i start my C++ journey I need to be clear of it.
IDE suggestion ? (VsCode | CLion)



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

muopt: a C++17 micro-library for argument parsing

Hello! I wanted to share a project that I've been working on for the last few days, a small argument parsing library called muopt. It started from a quite popular Rust crate called lexopt that I use in one of my CLI Rust projects. I wanted something similar to lexopt and couldn't find it for C++, so I decided to write my own.

muopt is more of a tokenizer/lexer than it is a parser. It doesn't "connect" a value to its option and just views them as an argument. muopt is intended to be minimal and bare-bones. Below is a really simple example of muopt in action.

#include "muopt/muopt.hpp"
#include <iostream>

int main(int argc, char argv) {
muopt::Parser parser(argc, argv);

while (std::optional<muopt::Arg> arg = parser.next()) {
if (arg->islong("help"))
std::cout << "usage: example [--input FILE]\n";
if (arg->islong("input"))
std::cout << parser.argvalue().valueor("") << '\n';
}
}

The code above will match the arguments --help and -h. Both will print out the usage message. It will also match --input=Hello or --input Hello and print out the value. The README has a deeper explanation on how muopt works and the repo has more examples.

muopt is still very early; it's not even released yet. I'm still debating on how to take on certain things, for example the arg_value() return type and how errors should be handled. Any suggestions are welcomed!

GitHub: https://github.com/secona/muopt

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

C++26: what is reflection and how to use it
https://techfortalk.co.uk/2026/07/25/c26-what-is-reflection-and-how-to-use-it/

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

Modern c++: operations on function pointers will break the constexpr function.

I'm on MSVC/c++23.

I used some trick to generate type id at compile time:

export template<typename... T> void typeid() {}
export using typeidt = void(*)();
//
typeidt oneid = typeid<int>;


I’ve found that whenever I try to cast a \`type\id` value to an integer or simply perform a magnitude comparison within a `constexpr` function (even when the call chain is entirely resolved at compile time), the function ceases to be `constexpr`, or MSVC simply ignores the relevant code.

template<typename A, typename B>
constexpr auto someconstexprfunction()
{
typeidt a = typeid<A>;
typeidt b = typeid<B>;

//Total if block will be ignored, and the function will not be constexpr anymore.
if (a < b)
{
//discard
}
else
{
//discard
}

//cast the pointer to sizet then the function will not be constexpr anymore.
return (sizet)a;
}

How to fixed the case?

Or another type id solution at compile time will be nice(I have try so many implementation, none of them work correctly in compile time).

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