-
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
Do you prefer 'int ptr' or 'int ptr'?
This is a style question.
With pointers and references, do you put the symbol next to the type or the name?
On one hand, I can see putting it with the type, since the type is 'a pointer to an int.'
But I can also see it leading to bugs. For example, when trying to declare two such pointers:
int* a, b; // This creates a pointer to an int and an int.
(Note: I know it isn't good practice to not initialise, but it's just an example)
So, what is the predominant wisdom on this issue? Which do y'all use and why?
https://redd.it/1q08le3
@r_cpp
Best way to use AI assistants without vibe coding
I come from a Fortran and python back ground and wish to quickly get started in C++ for some projects. I’m trying to use AI as a learning + design assistant without sliding into vibe-coding (prompting the AI assistant to generate code). I want workflows where AI helps me brainstorm solutions and architecture designs, catch bad practices, find errors, suggest new features beneficial to be used in my projects and learn syntax on the fly.
How to configure the github copilot to better achieve this purpose? What are your best resources—tutorials, blog posts, videos, or prompt “protocols”—for using ChatGPT/Copilot this way?
https://redd.it/1pztxe2
@r_cpp
executor affinity for ALL awaitables
I've been working on robust C++20 coroutine support in beast2 and I ran up against the "executor affinity" problem: making sure that tasks resume in the right context when they await another coroutine that might switch the context. I found there is some prior art (P3552R3) yet I am deeply unsatisfied to see it only works with senders. I came up with a general solution but I am a coroutine noob and it is hard to imagine that I can possibly be correct. I would like to know if there is a defect in my paper.
Simplifying P3552R3 with make_affine
This paper proposes make\_affine as a new reusable component for P3552R3, complementing the existing as\_awaitable and with\_awaitable\_senders building blocks. Unlike the sender-constrained affine\_on algorithm, make\_affine provides scheduler affinity for any awaitable, not just senders. This extends P3552R3's design philosophy of reusable components to cover the entire awaitable ecosystem.
https://github.com/vinniefalco/make\_affine/blob/master/p-make-affine.md
Yes I know that P3552R3 is already accepted yet I'd still like to know if I have a defect. Working code is also in the repo:
https://github.com/vinniefalco/make\_affine
Thanks
https://redd.it/1pzmei3
@r_cpp
StockholmCpp 2025, C++ Quiz Compilation 🎯
https://youtu.be/rlpqhpvDGDs
https://redd.it/1pzjhh9
@r_cpp
C++20 Modules: Best Practices from a User's Perspective
https://chuanqixu9.github.io/c++/2025/12/30/C++20-Modules-Best-Practices.en.html
https://redd.it/1pzbnzy
@r_cpp
Returning to C++
I was a sw dev in C/C++ from 1995 to 2006 at both Intel and Microsoft. I then switched gears to do build/release engineering and configuration management. When DevOps replaced that path in 2018ish, I started to lose interest. I want to switch back to CPP development now. I have Stroustrup's C++11 book along with his programming principles and practice. I have looked online for how to ramp up for interviews as well.
To really prepare myself for the market now, are there other suggestions for getting myself job ready?
https://redd.it/1pz5phd
@r_cpp
SimpleBLE v0.10.4 - The cross-platform Bluetooth library that just works
Hey everybody, SimpleBLE v0.10.4 is out! We focused on making the most versatile Bluetooth library even more reliable.
For those who don’t know, SimpleBLE is a cross-platform Bluetooth library with a very simple API that just works, allowing developers to easily integrate it into their projects without much effort, instead of wasting hours and hours on development.
Let’s review some of the most important changes of this new release.
Introducing Advanced Features
We’ve recently added scaffolding to allow users to configure the behavior of internal components as well as interacting directly with them. This feature is currently at an early stage of development, but will significantly increase the value and versatility you can extract out of SimpleBLE.
New Linux Backend In Progress
We started working on a full rewrite of our Linux backend, with the goal of exposing peripheral capabilities to the wider public. During this time, we’ve created a full copy of the legacy Linux backend and made it the default until the new backend is complete. You can test the nightly versions of the new backend with a new configuration flag,
Stability Fixes
Retrieving the same adapter multiple times now always returns the same underlying objects. Fixed bugs causing freezes, crashes and race conditions. Python source distributions now include all required files. All the good stuff.
See for yourself how easy it is to get started by looking at our examples on GitHub.
If you’re building BLE products or projects, we’d love to hear from you!
Want to know more about SimpleBLE's capabilities or see what others are building with it? Ask away!
https://redd.it/1pyud1r
@r_cpp
Why is C++ still introducing standard headers?
Modules was standardised in C++20 and import std; was standardised in C++23.
In C++26 it looks like new library features will be in provided in headers e.g. <simd>. When adding new library features should they not be defined within the standard modules now instead of via headers? Does defining standard headers still serve a purpose?
One obvious answer to this is is because modules aren't fully supported, it allows these new features to be implemented and supported without depending on modules functionality. While this helps adoption of the new features I suspect it will mean module implementations will be efectively de-prioritised.
https://redd.it/1pyl6zq
@r_cpp
Upgraded my Maze Solver
https://github.com/Radhees-Engg/Flood-Fill-with-DFS-maze-solver-algorithm-
https://redd.it/1pyhdal
@r_cpp
Saucer v8 released - A modern, cross-platform webview library
A new version of saucer has been released!
The update includes a refactor of the C-Bindings as well as (optional) C++ Exception support for exposed functions as well as some other QoL features such as a build-hook for refreshing embedded files!
I have also refactored the README a little, as suggested in reply to an earlier update post :)
Feel free to check it out! I'm grateful for all kinds of feedback :)
GitHub: https://github.com/saucer/saucer
Documentation: https://saucer.app/
https://redd.it/1pxr169
@r_cpp
Unlocking the value of C++20 - Alex Dathskovsky - Meeting C++ 2025
https://www.youtube.com/watch?v=5h4djuyx4Nk
https://redd.it/1pxdmaw
@r_cpp
uniOS - A scratch-built x86-64 operating system kernel written in C++20.
https://github.com/unionyxx/uniOS
https://redd.it/1pwy0p7
@r_cpp
Behl: Lua-inspired scripting language with C-like syntax, implemented in C++20.
https://github.com/behl-lang/behl
https://redd.it/1pwd4dg
@r_cpp
Microsoft wants to replace its entire C and C++ codebase
https://www.theregister.com/2025/12/24/microsoft_rust_codebase_migration
https://redd.it/1pw9mqb
@r_cpp
C++ logging library - something I've been working on, Pt. 5
Hello everyone,
You may not know, but it has become tradition for me to post an update about my logging library at the end of every year. Your critique and feedback have been invaluable, so thank you sincerely.
The logger is very fast and makes no heap allocations per log call. To achieve that, the logger uses several purpose-specific pre-allocated static buffers where everything is formatted in-place and memory is efficiently reused. It supports both synchronous and asynchronous logging. It's very configurable, so you can tailor it to your specific use case, including the sizes of the pre-allocated buffers I mentioned.
The codebase is clean, and I believe it's well documented, so you'll find it relatively easy to follow and read.
Whats new since last year:
A lot of stability/edge-case issues have been fixed
The logger is now available in vcpkg for easier integration
What's left to do:
Add Conan packaging
Add FMT support(?)
Update benchmarks for spdlog and add comparisons with more loggers(performance has improved a lot since the benchmarks shown in the readme)
Rewrite pattern formatting(planned for 1.6.0, mostly done, see pattern_compiler branch, I plan to release it next month) - The pattern is parsed once by a tiny compiler, which then generates a set of bytecode instructions(literals, fields, color codes). On each log call, the logger executes these instructions, which produce the final message by appending the generated results from the instructions. This completely eliminates per-log call pattern scans, strlen calls, and memory shifts for replacing and inserting. This has a huge performance impact, making both sync and async logging even faster than they were.
I would be very honoured if you could take a look and share your critique, feedback, or any kind of idea. I believe the library could be of good use to you: https://github.com/ChristianPanov/lwlog
Thank you for your time and happy holidays,
Chris
https://redd.it/1pvixcz
@r_cpp
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/1q02r5b
@r_cpp
Cache-Friendly C++
Talk from Jonathan Müller at CppCon 2025
https://www.youtube.com/watch?v=g\_X5g3xw43Q
https://redd.it/1pzr7fy
@r_cpp
Why std::span Should Be Used to Pass Buffers in C++20
https://techfortalk.co.uk/2025/12/30/stdspan-c20-when-to-use-and-not-use-for-safe-buffer-passing/
https://redd.it/1pzlov0
@r_cpp
The production bug that made me care about undefined behavior
https://gaultier.github.io/blog/the_production_bug_that_made_me_care_about_undefined_behavior.html
https://redd.it/1pzcgud
@r_cpp
I wrote a GitHub Action to select an MSVC version
https://blog.ganets.ky/MsvcGha/
https://redd.it/1pz6nuw
@r_cpp
I tried building a “pydantic-like”, zero-overhead, streaming-friendly JSON layer for C++ (header-only, no DOM). Feedback welcome
Hi r/cpp
I’ve been experimenting with a C++23 header-only library called JsonFusion: your C++ types are the schema, and the library parses + validates + populates your structs in one pass (no handwritten mapping layer).
My motivation: there are already “no glue” typed approaches (e.g. Glaze, reflect-cpp) — but they are not a good fit for the small-embedded constraints I care about (streaming/forward-iterator parsing, avoiding heap usage / full buffering, and keeping template/code-size growth under control across multiple models). I also haven’t found anything with the full set of features I would like to have.
At the same time, the more “DOM-like” or token-based parsers (including popular embedded options like ArduinoJson/jsmn/cJSON) fundamentally push you into tradeoffs I wanted to avoid: either you preallocate a fixed DOM/token arena or you use the heap; and you almost always end up writing a separate, manual mapping + validation layer on top (which is powerful, but easy to get wrong and painful to maintain).
Repo/README: github.com/tucher/JsonFusion
Docs are still in process, but there’s a docs/ folder, benchmarks, and a test suite in the repo if you want to dig deeper.
What it tries to focus on (short version):
- Zero glue / boilerplate: define structs (+ optional annotations) and call Parse().
- Validation as a hard boundary: you either get a fully valid model, or a detailed error (with JSON path).
- No “runtime subsystem”: no allocators/registries/config; behavior is driven by the model types.
- Streaming / forward-iterator parsing: can work byte-by-byte; typed streaming producers/consumers for O(1) memory on non-recursive models.
- Embedded friendliness: code size benchmarks included (e.g. ~16–21KB .text on Cortex-M with -Os, ~18.5KB on ESP32 -Os in the provided setup).
- CBOR support: same model/annotations, just swap reader/writer.
- Domain types are intentionally out of scope (UUID/date/schema algebra, etc.) — instead there are transformers to compose your own conversions.
Important limitations / caveats:
- GCC 14+ only right now (no MSVC/Clang yet).
- Not a JSON DOM library (if you need generic tree editing, this isn’t it).
- There’s an optional yyjson backend for benchmarking/high-throughput cases, but it trades away the “no allocation / streaming” guarantees.
I’m not claiming it’s production-ready — I’d love feedback on:
- API/ergonomics (especially annotations/validation/streaming)
- C integration / interoperability approach (external annotations for “pure C” structs, API shape, gotchas)
- what limitations are unacceptable / what’s missing
- compile times / template bloat concerns
- whether the embedded/code-size approach looks sane
Thanks for reading — the README is the best entry point, and I’m happy to adjust direction based on feedback.
https://redd.it/1pyw560
@r_cpp
TeaScript C++ Library 0.16.0 - this new version of the embeddable scripting language comes with ...
... a distinct Error type, a catch statement, default shared parameters, BSON support and more.
With the Error type and together with the new catch statement (similar as in and highly inspired by Zig) a modern and convenient way of error handling is available now.
All new features and changes are introduced and explained in the corresponding blog post:
https://tea-age.solutions/2025/12/22/release-of-teascript-0-16-0/
Github of the TeaScript C++ Library:
https://github.com/Florian-Thake/TeaScript-Cpp-Library
TeaScript is a modern multi-paradigm scripting language which can be embedded in C++ Applications but can be also used for execute standalone script files with the help of the free available TeaScript Host Application.
Some highlights are
# Json Support
Integrated JSON support for import/export from/to File | String | C++ | TeaScript Tuples.
Compatible with the most common C++ Json Libraries, namely nlohmann::json, RapidJson, Boost.Json and Pico Json.
You can pick one of the mentioned which will be used inside TeaScript (Pico Json is integrated and the default, feature can be switched off) but on C++ level you can import/export to all of them simultaneously if desired. Ready to use JsonAdapters for all of the libraries are available.
Further reading: Json Support
# Coroutine like usage
With the help of the yield and suspend statements you can use script code similar like a coroutine and yielding intermediate values and pause script execution.
Furthermore you can set constraints for suspend the execution automatically after a certain amount of time or executed instructions.
Further reading: Coroutine like usage
# Direct usage of supported C++ types
Use, for example, same instances of a std::string (String in TeaScript) or std::vector<unsigned char> (Buffer in TeaScript) in C++ and TeaScript without conversion or extra copy.
This is not possible with other (non C++) embedded scripting languages.
See also: Bidirectional interoperability
# Web Server / Client Preview
HTTP Server and Client are possible as a preview feature with automatic Json payload handling.
Further reading: Web Server / Client
# Additionally
TeaScript has some maybe unique but at least from my perspective shining features:
\- Uniform Definition Syntax
\- Copy Assign VS Shared Assign
\- Tuple / Named Tuple: Part I, Part II
I hope, you enjoy with this release and/or find a good usage for your application.
I will be happy for any constructive feedback, suggestions and/or questions.
Happy coding! :)
https://redd.it/1pyqp4s
@r_cpp
Exploring C++20 std::chrono - Calendar Types
https://www.cppstories.com/2025/chrono-calendar-types/
https://redd.it/1pyk3lr
@r_cpp
Mike shah if you are reading this your playlist is goated.
got a job because of that guy
https://redd.it/1pye51z
@r_cpp
Seeking advice on building a strong C++ gameplay portfolio
Hi all,
I’m looking for technical, portfolio-focused advice from experienced game developers, especially those with backgrounds in C++ gameplay programming, simulation-heavy systems, or grand strategy–style games.
I’ve been working with C++ for a while and have built several projects in the past, including:
* A small custom engine (core loop, input, minimal rendering),
* Some physics and systems experiments,
* And a few gameplay-focused prototypes.
Recently, I made a decision I now question: I deleted all of those projects because I felt they were “not good enough” or didn’t reflect the level I want to reach. In hindsight, this feels less like quality control and more like a destructive reset loop.
My long-term goal is to become a gameplay programmer on complex, systems-driven games (grand strategy like EU/CK/Victoria, but also action games like Soulsborne / Monster Hunter). My primary interest is gameplay logic and simulation.
I’m also open to learning game engine development at a foundational level (architecture, update loops, data flow, tooling), but I see that as a secondary path that supports gameplay work, not as a goal in itself. I’m deliberately trying to avoid spending years on graphics or low-level tech that doesn’t translate into better gameplay systems.
What I’m trying to understand, from a technical and strategic standpoint:
* What kinds of C++ projects actually make a strong gameplay-focused portfolio today?
* How do you decide a project is “good enough” to keep and present, rather than delete and restart? (I tend to restart when I notice architectural flaws or design weaknesses. At what point is refactoring and iteration more valuable than starting from scratch?)
* How do you structure learning so projects accumulate value over time instead of being thrown away?
* If you were starting again today, aiming for a C++ gameplay programmer role, what would you build first, and what would you deliberately not build?
I’m not looking for motivation or generic encouragement.
Thanks in advance to anyone willing to share experience or critique this approach.
https://redd.it/1pxd8w7
@r_cpp
I’m building a small C++ rendering library (VGLX). Feedback welcome.
I’ve been working on a small C++ rendering library called VGLX.
The goal is clarity over features. Explicit ownership. Minimal magic.
Some constraints I set for myself:
* Modern C++ (C++20).
* OpenGL backend for now. Vulkan later.
* Asset importing is offline. Runtime loaders only deal with engine-native formats.
* No global asset managers or hidden caches.
* Scene graph and lifetimes are explicit and boring by design.
It’s not a game engine. It’s closer to a rendering library you can read, reason about, and extend.
Docs + examples:
[https://vglx.org]()
Repo:
[https://github.com/shlomnissan/vglx]()
If you have opinions on API shape, ownership, or things that look wrong, I’d like to hear them.
https://redd.it/1px91ls
@r_cpp
Header-only library for creating simple text-based command interpreters
Hi all,
I made a small header-only library called conco ("console commands") designed to make building simple command interpreters, REPLs, or Quake-like game consoles trivial.
The core idea is to take a raw string like add 10 20 and automatically dispatch it to a C++ function like int add(int x, int y);. The library handles tokenization, type conversion, argument passing and result stringification for you.
You can bind regular functions, capturing lambdas or member functions as your commands. There is no global state and no dynamic memory allocations. The library is well suited for embedded development, where creating text-based debug interfaces over UART/serial port might come handy.
Basic example:
void logenable() { ... }
int sum(int a, int b) { return a + b; }
int main()
{
// List of available commands
const conco::command commands[] = {
{ logenable, "log.enable;Enable logging" },
{ sum, "sum;Sum of two integers" }
};
// Calls log_enable
conco::execute(commands, "log.enable");
char buffer256 = { 0 };
// Calls sum(123, 456), writes stringified result to buffer
conco::execute(commands, "sum 123 456", buffer);
std::println("{}", buffer); // Outputs: 579
}
I would love to hear your feedback or roast of the implementation! Check out the GitHub repository link here:
https://github.com/P-i-N/conco
Cheers!
https://redd.it/1pwvui8
@r_cpp
Who is the best C++ Programmer You Know.
I'm current an engineering student and was wondering who the best C++ programmers yall know are. Are they students, FAANG employees, researchers, mathematicians, etc? How can i become a better C++ dev and what makes a good C++ dev? Curios on yall's thoughts.
https://redd.it/1pwbb50
@r_cpp
I need C++ code about 240 line if you think you can handle it in a one day
Please dm to me if you can do
https://redd.it/1pvsjb6
@r_cpp
Software Architecture with C++, Second Edition: reviews, thoughts
The second edition of the book was recently published. The first edition was met with mixed reviews, with some people liking it and others disliking it. Overall, it appears the book has been significantly revised and expanded with practical examples for writing and deploying C++ microservices. Does anyone have any opinions on this book?
Software Architecture With C++ by Adrian Ostrowski, Piotr Gaczkowski
Google Books Software Architecture with C++: Designing robust C++ systems with modern architectural practices, Edition 2
https://redd.it/1pva16y
@r_cpp