-
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
Rostyslav Skrypnyk: Getting Started With ranges
https://youtu.be/wpi9Cr1LvYE
https://redd.it/1ljjtw0
@r_cpp
Getting Down in the Bits with Boost.Multiprecision (July 9th)
Getting Down in the Bits with Boost.Multiprecision
If your application needs more precision than the built-in integer or floating-point types, C++ provides facilities for creating your own data types that can fulfill this need. There are a variety of libraries that provide such facilities, each with their own class names and API. Boost.Multiprecision provides a unified way of interacting with multiple precision integer, rational, real (floating-point) and complex number data types.
This month, Richard Thomson will give us an introduction to using Boost.Multiprecision for floating-point types in order to perform arbitrary zooms into the well known Mandelbrot set fractal.
https://redd.it/1ljjx7m
@r_cpp
Stenos: fast compression of binary data
https://github.com/Thermadiag/stenos
https://redd.it/1ljbbzw
@r_cpp
The talklisting for Meeting C++ 2025
https://meetingcpp.com/mcpp/schedule/talklisting.php
https://redd.it/1lj8418
@r_cpp
definition (because this is encoded in the operand). The context in which it is called is inside A, therefore there would be no syntax error here.
//3 We take the reflection of the original function, and copy it to a new reflection, now "detached" because it is non const. Therefore it has all the same properties as original_fn_refl, except it is now detached.
//4 We edit the properties of the reflection object via standard library API that is available only to non-const versions of std::meta::info (that is, these are non-const member functions).
//5 Lets unpack the return statement:
5a. We return ^^(...) which is a reflection of something, okay.
5b. The content of it is
[: build_const_getter:] {
return const_cast<class_name*>(this).[:const_foo:]();
}
^^(...) block, and from the fifth rule, we say it is "unevaluated", the same way we can have illegal code inside decltype. This is just SFINAE! Therefore the compiler does not actually inject the member function here.^^(...) would be a const reflection of the member function definition (which was not injected, only parsed to create a reflection).const/non-const member functions!const! That is it!const in the library would be a major breaking change.const now (at least for the library) seems harmless, and also conecptually correct; as all the functions are get or is.
[https://www.youtube.com/watch?v=iZsRxLXbUrY](https://www.youtube.com/watch?v=iZsRxLXbUrY)
2025-05-26 - 2025-06-01
* The battle over Heterogeneous Computing :: Oren Benita Ben Simhon **-** [https://www.youtube.com/watch?v=RxVgawKx4Vc](https://www.youtube.com/watch?v=RxVgawKx4Vc)
* A modern C++ approach to JSON Sax Parsing :: Uriel Guy - [https://www.youtube.com/watch?v=lkpacGt5Tso](https://www.youtube.com/watch?v=lkpacGt5Tso)
**Using std::cpp**
2025-06-16 - 2025-06-22
* Closing Keynote: C++ as a 21st century language - Bjarne Stroustrup - [https://www.youtube.com/watch?v=1jLJG8pTEBg](https://www.youtube.com/watch?v=1jLJG8pTEBg)
* Known pitfalls in C++26 Contracts - Ran Regev - [https://www.youtube.com/watch?v=tzXu5KZGMJk](https://www.youtube.com/watch?v=tzXu5KZGMJk)
2025-06-09 - 2025-06-15
* Push is faster - Joaquín M López Muñoz - [https://www.youtube.com/watch?v=Ghmbsh2Mc-o&pp=0gcJCd4JAYcqIYzv](https://www.youtube.com/watch?v=Ghmbsh2Mc-o&pp=0gcJCd4JAYcqIYzv)
* Cancellations in Asio: a tale of coroutines and timeouts - Rubén Pérez Hidalgo - [https://www.youtube.com/watch?v=80Zs0WbXAMY](https://www.youtube.com/watch?v=80Zs0WbXAMY)
2025-06-02 - 2025-06-08
* C++ packages vulnerabilities and tools - Luis Caro - [https://www.youtube.com/watch?v=sTqbfdiOSUY](https://www.youtube.com/watch?v=sTqbfdiOSUY)
* An introduction to the Common Package Specification (CPS) for C and C++ - Diego Rodríguez-Losada - [https://www.youtube.com/watch?v=C1OCKEl7x\_w](https://www.youtube.com/watch?v=C1OCKEl7x_w)
2025-05-26 - 2025-06-01
* CMake: C'mon, it's 2025 already! - Raúl Huertas - [https://www.youtube.com/watch?v=pUtB5RHFsW4](https://www.youtube.com/watch?v=pUtB5RHFsW4)
* Keynote: C++: The Balancing Act of Power, Compatibility, and Safety - Juan Alday - [https://www.youtube.com/watch?v=jIE9UxA\_wiA](https://www.youtube.com/watch?v=jIE9UxA_wiA)
https://redd.it/1lil65a
@r_cpp
How good is w3schools for learning C++
Title says all. If there are any other free courses available on youtube worth checking out then do share :P
https://redd.it/1lilmot
@r_cpp
C++17 - Iterating Problems
https://mementum.github.io/cpp17-iterating-problems/
https://redd.it/1liakhm
@r_cpp
C++ as a 21st century language - Bjarne Stroustrup
https://youtu.be/1jLJG8pTEBg
https://redd.it/1li7dql
@r_cpp
C++17 - Iterating Problems
https://mementum.github.io/c++17-iterating-problems
https://redd.it/1li1kja
@r_cpp
Any news on Safe C++?
I didn't hear from the Safe C++ proposal for a long time and I assume it will not be a part of C++26. Have any of you heard something about it and how is it moving forward? Will it be than C++29 or is there a possibility to get it sooner?
https://redd.it/1lhbqua
@r_cpp
I think I created a data structure that might have some good applications (Segmented Dynamic Arrays)
Hello everyone,
This is my first time posting here. I'm a beginner in C++ (not in programming in general), and even though I've known the language for 2–3 years, I haven't really explored the advanced parts yet.
Recently, I’ve been experimenting with a concept I’m calling a segmented dynamic array. It’s basically a vector of arrays (or chunks), and I’ve found it to be way more flexible than a regular vector in some specific scenarios. Here’s what I’ve noticed:
Middle insertions are significantly faster — like, by a lot.
Sorted searching (via binary search) is around 20% faster.
Deletions (though not implemented yet) should theoretically be faster too.
For regular end insertions, vector is still faster, but only by a small margin.
I’m curious — is this kind of structure already a known thing? Or could it be something new that actually has practical use? If it really does outperform std::vector in certain operations, could it be worth turning into a reusable library?
Most of the code is my own, though I did use some SIMD instructions with chatgpt's help, I don’t fully understand that part yet.
If anyone here is experienced with data structures or performance testing, I’d really appreciate some feedback, especially on how to benchmark things properly or any ideas for improving it further.
Thanks in advance!
https://redd.it/1lgvkc2
@r_cpp
So does it matter now in C++ modules whether to separate interface and implementation to reduce compilation time?
It's very hard to find resource on this. I've been using c++ modules and it felt much better code organization wise than the standard header+cpp files.
But I've been putting both declaration and definition inside a .cppm file. It seems to have increased compilation time even compared to my previous header+cpp files. Should I have not merged the declaration and definition of my functions and class on a single file? I thought we don't need to care about this anymore and the compiler will handle it...
https://redd.it/1lgvq4d
@r_cpp
Reflection has been voted in!
Thank you so much, u/katz-dm and u/BarryRevzin for your heroic work this week, and during the months leading up to today.
Not only did we get P2996, but also a half dozen related proposals, including annotations, expansion statements, and parameter reflection!
(Happy dance!)
https://redd.it/1lgs35k
@r_cpp
I made a signle thread coroutine lib
Yes, it's for games, or any applications that are update-based. Based on C++20, of course. Inspired by Unity's coroutine (but better) and UniTask (no cancellation token needed).
I tried very hard to make it lightweight and intuitive. You can embed it anywhere that has a regular update.
There's already eu5coro, but there must be a need for other engines/frameworks, so I made one for myself and others like me.
Let me know your thoughts!
https://github.com/ShirenY/tokoro
https://redd.it/1lgn5s2
@r_cpp
Why haven't modules been a higher priority for EDG?
On EDG's list of C++20 features, only 1 out of 11 modules papers have been implemented so far. Visual Studio uses EDG's front-end compiler for their intellisense, so using modules with MSVC means having red squiggles everywhere and extremely slow performance, to the point where they are practically unusable. Given that it's been five years since modules were voted in, that the actual MSVC compiler has decent support for them, and that Microsoft's STL now has standard library modules, why hasn't EDG caught up yet?
https://redd.it/1ljkler
@r_cpp
How Electronic Arts Standardized their C++ Builds Across Windows and Linux using Visual Studio Build Tools
https://developer.microsoft.com/en-us/games/articles/2025/06/case-study-electronic-arts-visual-studio-build-tools/
https://redd.it/1ljeywc
@r_cpp
From 300s to 60s: C++ build boost by disabling SysMain
I had an interesting experience optimizing C++ build performance on Windows 11.
I'm using a fairly powerful PC for development. Initially, building a large project with about 1,500 .cpp files took around 90 seconds.
Six months later, on the same hardware, the build time increased to 300 seconds. I started investigating the reason.
Turns out the culprit was Windows’ performance optimization service — SysMain.
When it's running, about 60 GB of my 64 GB RAM gets used up. The system aggressively caches everything — whether it's useful or not.
After disabling SysMain, my average memory usage dropped to 16 GB out of 64,
and the build time improved dramatically — down to 60 seconds, 5× faster.
SysMain may have noble goals, but in my particular case, it was doing more harm than good.
Hope this info helps other developers out there.
https://redd.it/1ljb1zq
@r_cpp
C++ in JupyterLite (WebAssembly) — Interpreting C++ in the Web
https://blog.jupyter.org/c-in-jupyter-interpreting-c-in-the-web-c9d93542f20b
https://redd.it/1lj52y4
@r_cpp
Simple Generation for Reflection with splice and non const std::meta::info
I love the new Reflection feature forwarded for C++26.
After reading the main paper, and some future proposals for code injection, it occured to me that the reflection proposal can be extended to allow code injection in a very simple way. With no new conceptual leaps, just use the splice operator already introduced (with only a minor tweak to the current design).
I wonder if this approach was explored or discussed before? I hope to start a discussion.
If this seems favourable, I hope the needed change to the C++ 26 design can still be applied (spoiler: just add const everywhere, it seems harmless, I think).
How it works?
We define 4 new rules, and 2 minor changes to the existing reflection facilities, and we achieve code injection via splicing:
1(Change). The reflection operator ^^ always returns const reflection objects (const std::meta::info and the likes of it).
2(Change). The splice operator [: :] applied to const reflection objects behaves the same as today.
3(New). We can create non-const versions of reflection objects (for example via copying const ones) and edit their properties. Those are "non-detached" to any real entity yet; the get_source_location function on them is not defined (or always throws an exception).
4(New). When the splice operator takes non-const reflection obejct, it behaves as an injection operator. Therefore in any context in which splicing is allowed, so would injection. More precisely it is performed in two steps: dependent parsing (based on the operand), followed by injecting.
5(New). The content of the reflection operator is an "unevaluated" context (similar to decltype or sizeof).
6(New). Splicing in unevaluated context performs only parsing, but not injecting it anywhere.
Motivating Example
Generating a non const pointer getter from const getter (the comments with numbers are explained below):
consteval std::meta_info create_non_const_version(const std::meta_info original_fn_refl); //1
//usage
struct A
{
int p;
const int* get_p() const { return &p;}
/*generate the non const version
int * get_const() {return const_cast<const int *>(const_cast<const A*>(this)->get_p()); }
*/
consteval {
const std::meta::info const_foo = ^^get_p;
std::meta_info new_foo = create_non_const_version(const_foo); // a new reflection object not detached to any source_location
/*injection happens here*/
[:new_foo :]; //2
}
/* this entire block is equivalent to the single expression: */
[:create_const_version(^^get_p):]
};
//implementation of the function
consteval std::meta_info create_non_const_version(const std::meta_info original_fn_refl)
{
std::meta::info build_const_getter = original_fn_refl; //3
// we know it is a member function as the original reflection was, so the following is legal:
build_const_getter.set_const(false); //4
//find the return type and convert const T* into T* (this is just regular metaprogramming, we omit it here)
using base_reult_t = pmr_result_t<&[:original_fn_refl:]>;
using new_result_type = std::remove_const_t<std::remove_pointer_t<base_reult_t>>*;
build_const_getter.set_return_type(^^new_result_type);
return ^^([: build_const_getter:] {
return const_cast<class_name*>(this).[:const_foo:]();
}); //5
}
New C++ Conference Videos Released This Month - June 2025 (Updated To Include Videos Released 2025-06-16 - 2025-06-22)
**C++Online**
2025-06-16 - 2025-06-22
* Data Oriented Design: Machine Learning One Million Times Faster - Andrew Drakeford - C++Online 2025 - [https://youtu.be/MknFD9ar1-4](https://youtu.be/MknFD9ar1-4)
* External Polymorphism and C++ Type Erasure - A Very Useful Dance of Design Patterns - Eduardo Madrid - C++Online 2025 - [https://youtu.be/HGhAc5YZUps](https://youtu.be/HGhAc5YZUps)
* MISRA C++2023 for All C++ Developers - Loïc Joly - C++Online 2025 - [https://youtu.be/MZVPMGWuVys](https://youtu.be/MZVPMGWuVys)
2025-06-09 - 2025-06-15
* What Can C++ Learn About Thread Safety From Other Languages? - Dave Rowland **-** [https://youtu.be/SWmpd18QAao](https://youtu.be/SWmpd18QAao)
* How to Parse C++ - Yuri Minaev - [https://youtu.be/JOuXeZUVTQs](https://youtu.be/JOuXeZUVTQs)
* Debugging C++ Coroutines - André Brand - [https://youtu.be/2NmpP--g\_SQ](https://youtu.be/2NmpP--g_SQ)
2025-06-02 - 2025-06-08
* Keynote: Six Impossible Things in Software Development - Kevlin Henney - C++Online 2025 **-** [https://youtu.be/KtN8PIYfypg](https://youtu.be/KtN8PIYfypg)
* JSON in C++ - Designing a Type for Working With JSON Values - Pavel Novikov - C++Online 2025 - [https://youtu.be/uKkY-4hBFUU](https://youtu.be/uKkY-4hBFUU)
**ADC**
2025-06-16 - 2025-06-22
* Building Audio Applications using AI Models: Practical Lessons Learned - ChangHun Sung - [https://youtu.be/OAlHWRQhewE](https://youtu.be/OAlHWRQhewE)
* Profiling Neural Audio Plugins - Dharanipathi Rathna Kumar - [https://youtu.be/D0vmBwC2HyE](https://youtu.be/D0vmBwC2HyE)
* Inheriting Mantis (Synth) from Chris Huggett - Ben Supper - [https://youtu.be/N8YvYTSpUCk](https://youtu.be/N8YvYTSpUCk)
2025-06-09 - 2025-06-15
* Inter-Plugin Communication (IPC) - Breaking out of the Channel Strip - Peter Sciri - [https://youtu.be/X-8qj6bhWBM](https://youtu.be/X-8qj6bhWBM)
* Groove Transfer VST for Latin American Rhythms - Anmol Mishra & Satyajeet Prabhu - [https://youtu.be/qlYFX0FnDqg](https://youtu.be/qlYFX0FnDqg)
* How to Price an Audio Plugin - Factors to Consider When Deriving That One Elusive Value - James Russell - [https://youtu.be/AEZcVAz3Qvk](https://youtu.be/AEZcVAz3Qvk)
2025-06-02 - 2025-06-08
* Practical Steps to Get Started with Audio Machine Learning - Martin Swanholm - ADC 2024 - [https://youtu.be/mMM5Fufz6Sw](https://youtu.be/mMM5Fufz6Sw)
* MIDI FX - Node based MIDI Effects Processor - Daniel Fernandes - ADCx India 2025 - [https://youtu.be/jQIquVLGTOA](https://youtu.be/jQIquVLGTOA)
* Accelerated Audio Computing - Unlocking the Future of Real-Time Sound Processing - Alexander Talashov - ADC 2024 - [https://youtu.be/DTyx\_HsPV10](https://youtu.be/DTyx_HsPV10)
2025-05-26 - 2025-06-01
* Workshop: Inclusive Design within Audio Products - What, Why, How? - Accessibility Panel: Jay Pocknell, Tim Yates, Elizabeth J Birch, Andre Louis, Adi Dickens, Haim Kairy & Tim Burgess - [https://youtu.be/ZkZ5lu3yEZk](https://youtu.be/ZkZ5lu3yEZk)
* Quality Audio for Low Cost Embedded Products - An Exploration Using Audio Codec ICs - Shree Kumar & Atharva Upadhye - [https://youtu.be/iMkZuySJ7OQ](https://youtu.be/iMkZuySJ7OQ)
* The Curious Case of Subnormals in Audio Code - Attila Haraszti - [https://youtu.be/jZO-ERYhpSU](https://youtu.be/jZO-ERYhpSU)
**Core C++**
2025-06-02 - 2025-06-08
* Messing with Floating Point :: Ryan Baker - [https://www.youtube.com/watch?v=ITbqbzGLIgo](https://www.youtube.com/watch?v=ITbqbzGLIgo)
* Get More Out of Compiler-Explorer ('godbolt') :: Ofek Shilon - [https://www.youtube.com/watch?v=\_9sGKcvT-TA](https://www.youtube.com/watch?v=_9sGKcvT-TA)
* Speeding up Intel Gaudi deep-learning accelerators using an MLIR-based compiler :: Dafna M., Omer P - [https://www.youtube.com/watch?v=n0t4bEgk3zU](https://www.youtube.com/watch?v=n0t4bEgk3zU)
* C++ ♥ Python :: Alex Dathskovsky - [https://www.youtube.com/watch?v=4KHn3iQaMuI](https://www.youtube.com/watch?v=4KHn3iQaMuI)
* Implementing Ranges and Views :: Roi Barkan -
learning cpp
Is the geeksforgeeks course for cpp good? I got it in the recent sale as it was free didnt think much of it.
Initially I was going to learn from Udemy Abdul Bari C++ course. Thoughts?
https://redd.it/1lih28w
@r_cpp
Why some applications sound simple have a large code base
I'm a noob student want to learn more, thanks for the support.
I'm planning to write a Key-Value store in-memory server for learning purpose. I can't imagine how this easy peasy type of application become something that people talk about day to day, year to year.
I feel like it's not too hard and the task is clear. You need to implement your hash table that fast enoguh, lock mechanics for multi-threading, choose an appropriate allocator to manage memory efficiently, some strategies to handle incidents, and socket programming to handle request. Sound easily and not many things to do right? I think my implementation won't be more than 5000 lines of code.
More over, I've seen many application with simple feature but very large code base. But now we ignore these cases, can you give me some intuitive thoughts about what we can do, and how much we can do to improve our application?
https://redd.it/1li8rzq
@r_cpp
Can anyone recommend a language (e.g., an XML tag suite) for describing C++ class interfaces?
I'm currently working on a research paper that has a data set which includes some C++ code. As a result, I've started to think about formats for documenting C++ classes. Given the most popular current standards (that I know of), I'm assuming my document will be formatted in JATS (Journal Article Tag Suite) and the data set will be a Research Object Bundle. JATS is based on XML, and although Research Objects internally use JSON one could certainly create XML files to describe dataset contents.
Since the C++ code is an intrinsic part of the data set, I would like to use some dedicated language (either XML or something domain-specific) to describe basic C++ details: what are the classes, public methods, pre-/post-conditions, inter-class dependencies, etc. This sort of thing usually seems to be the provenance of IDLs or RPC, but that's not my use case: I'm talking about normal methods, not web services or API endpoints; and my goal in the formal description is not code-generation or validation or anything "heavy"; I just want a machine-readable documentation of the available code. I don't need a deep examination of the code as in IPR or LLVM.
Such might seem to be a pointless exercise. But my speculation is that with the rise of things like "Code as a Research Object" there will eventually emerge conventions guiding how code in an open-access dataset context is documented, potentially consumed by IDEs and by data repositories (so that datasets could be queried for, e.g., names of classes, methods, or attributes).
https://redd.it/1li50wt
@r_cpp
Discover C++26’s compile-time reflection
https://lemire.me/blog/2025/06/22/c26-will-include-compile-time-reflection-why-should-you-care/
https://redd.it/1lhv8md
@r_cpp
Twiq - A simple Qt6 app to create loading spinner animations (educational project)
i! This is a small project I made to learn and practice C++ and Qt6. Twiq lets you design basic loading spinner animations and export them as GIFs. It’s not a professional tool, but it’s useful for understanding how to build animation apps with Qt and some graphics libraries.
If you want to see how to create simple animations and work with GIF export in C++, feel free to check it out. Any feedback or suggestions are welcome!
Github
https://redd.it/1lgzzqp
@r_cpp
Trip report: June 2025 ISO C++ standards meeting (Sofia, Bulgaria)
https://herbsutter.com/2025/06/21/trip-report-june-2025-iso-c-standards-meeting-sofia-bulgaria/
https://redd.it/1lgxdm8
@r_cpp
Navigating C++ Career Uncertainty
Hi everyone,
I’ve been working professionally with C++, and while I really enjoy the language and the kind of systems level work it allows I’ve noticed something that’s been bothering me more and more C++ job opportunities seem quite rare especially outside of the U.S. and Europe. I’m not based in either, and that adds to the challenge.
This scarcity leads to a constant fear of what if I lose my current job? How easy (or hard) will it be to find another solid C++ role from my region?
Someone suggested that I could start picking up backend web development freelancing as a safety net. The idea makes sense in terms of financial security, but I find it genuinely hard to shift away from C++. It’s the language I’m most comfortable with and actually enjoy working with the most.
So I wanted to ask:
Has anyone here used freelancing (especially backend work) as a backup or supplement to a C++ career?
How did you make peace with working in a different stack when your passion lies in C++?
Any advice or personal experiences on how to navigate this situation would be appreciated. I’m trying to be realistic without letting go of the things I love about programming.
Thanks
https://redd.it/1lgt8e8
@r_cpp
C++ developer role as a fresher
I am looking for job in c++/java domain as a fresher. I know a few companies that hire in c++ such as:
Keysight
Synopsys
Siemens
Cadence
Akamai
ClearTail
If anyone knows more companies like this then please drop a comment.
https://redd.it/1lgp1v2
@r_cpp
Trying to use if statement for char
I’m trying to check if player has inputted an X or O if else invalid but I get X or O is undefined
#include <iostream>
int main()
{
std::cout << "Welocme to TIC TAC TOE!\n";
std::cout << "Are you playing as X's or O's?\n";
char playersymbol;
std::cin >> playersymbol;
if (playersymbol ) {
}
else {
std::cout << "Invalid player symbol!";
}
std::cout << "You picked\n";
std::cout << playersymbol;
https://redd.it/1lggkel
@r_cpp