-
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
duolingo-like application?
I was wondering if someone has a nice duolingo-like application for practicing , and not losing problem solving skills
https://redd.it/1xns0bv
@r_cpp
C v.s. C++
Is it worth it to learn both? Preferences... main differences? Starting to learn C++ & someone suggested that I learn C in addition. I suppose I don't see the point since they're similar. When would it matter - or in what cases would I need to know C in addition to C++ ??
https://redd.it/1xnlc40
@r_cpp
How I design C++ classes
https://rafb.eu/blog/cpp-class-design/
https://redd.it/1xmu08f
@r_cpp
A Simple Introduction to std::simd [WIP]
https://ed94a9.github.io/posts/std-simd/
https://redd.it/1xmmeji
@r_cpp
Catastrophic misoptimization of byte-range equality comparison in all major C++ compilers (and Rust). Language issue or compiler issue?
Someone brought a C++ snippet that reduced to the following (std::array used instead of char* for consistency for later)
bool eq2(const std::array<char, 64>& lhs, const std::array<char, 64>& rhs) {
for (int i = 0; i < 64; ++i)
if (lhs[i] != rhs[i])
return false;
return true;
}
It basically returns true iff two 64 byte memory regions are a bitwise match. You'd think this can be optimized by modern compilers flawlessly, right? Right?! And the worst thing that can happen is it doesn't get autovectorized, right? Right?!
Well, to everybody's surprise... https://godbolt.org/z/v4d8G5ovh
GCC attempts to partially conditionally vectorize but doesn't want to use unaligned loads. Moreover its vectorization is way more cumbersome than it needs to be. Then after it finds a mismatch it... reverts to the unvectorized version?! Clang and MSVC do not even attempt to vectorize it - and in a way it makes them end up better than GCC, which is wild.
----------------
Now, to try to investigate we've checked how it looks in Rust. https://godbolt.org/z/K7xE3qc94. It does what GCC does but fully vectorized.
At this point we're confused as to what the source of the problem is. Are we missing something with respect to what transformations are allowed? Is it really that much to ask from the as-if rule?
As a sanity check we use std::array's operator==. https://godbolt.org/z/xPhPYMjvz. Oh would you look at that? Now the compilers can do well (ok not you MSVC. GCC also fumbles the flag register slightly). The situation is the same in Rust - https://godbolt.org/z/3GjWorze8. Not only does it vectorize correctly but the vectorized code is better - using vpxor.
-----------------
Ultimately this isn't just academical. Situations like this undermine the trust in the compiler at the most fundamental level. Not every place can use std::array, not everyone can use ranges and span yet. We could use `std::equal` but why does it matter so much? What if `!=` changes to `<` and there's no good solution anymore? To what degree are we supposed to be paranoid about basic optimizations being done or not?
The similarity of codegen between Rust and C++ would point to it being either a compiler issue or a fundamental code correctness issue. The fact that C++ Clang differs from Rust (LLVM) would suggest it's at least partially a language issue. Why is this extremely simple code so nasty?
https://redd.it/1xlyti8
@r_cpp
Would anyone be interested in learning Windows System Programming (Win32 to Kernel)?
I’m considering putting together a practical, hands-on course on Windows System Programming.
The course would start with Win32 programming and gradually move into Windows internals and kernel-mode development.
Topics would include:
Win32 API and Windows programming fundamentals
Processes, threads, synchronization and IPC
Memory management and I/O
Windows internals and system architecture
Kernel-mode programming and device drivers ( mini filter driver)
Hands-on projects using Visual Studio, WDK and WinDbg
I’ve been working in C/C++ and Windows systems and kernel programming for over 25 years.
I’d like to understand whether there is genuine interest in a course like this, particularly among developers who want to move beyond application programming and understand how Windows works internally.
Would you be interested? What topics would you most like to learn?
https://redd.it/1xkz9vr
@r_cpp
Hans Wennborg: Windows debug info - CodeView and PDB files
https://youtu.be/kKczw8AYKjo
https://redd.it/1xki1fn
@r_cpp
Upcoming C++ User Group meetings in November 2026
https://meetingcpp.com/meetingcpp/news/items/Upcoming-Cpp-User-Group-meetings-in-November-2026.html
https://redd.it/1xk7wxa
@r_cpp
Built a Microsoft-signed Windows kernel filter driver for keyboard & mouse input.
Capture, remap, block and forward input using a simple C++17 SDK.
Windows 10/11 x64.
https://github.com/TitanCSA/Interceptor-Keyboard-Mouse
\#cpp #windowskernel #gamedev
https://redd.it/1xjj6p1
@r_cpp
Pitfalls of bit fields in C++
https://pvs-studio.com/en/blog/posts/cpp/1423/
https://redd.it/1xje0k3
@r_cpp
The case against makefiles
https://thibaud.space/2026/10/the-case-against-makefiles.html
https://redd.it/1xiz5ce
@r_cpp
C++ BLAS Library for bringing two worlds togetherI would like
I would like to discuss the need (or no-need) for a C++ interface/libary that is intended to be a- building block for high level linear algebra packages and- low-level, hardware oriented implementations of special numerical operations.
The “high-level world” …
In the C++ world, you have libraries like Eigen, Blaze, … where you can matrix operations like
C = A * B;
and regarding performance often stops here. Because some experts figured out how to implement such that it’s fast.
Or maybe there is a short discussion why you should write
C.noalias() = A * B;
in Eigen.
And that’s great. In this world you wanna build something great based on Linear Algebra operations.
The “Low-level world” …
Then there is the world of BLAS (Basic Linear Algebra Subprograms), with implementations such as Intel MKL, OpenBLAS, BLIS, or Apple Accelerate. So for some reason there is money and time involved.
They provide implementations for the matrix product that are very efficient. But maybe not that user friendly to use. For example they provide a function for the operation
C ← βC + αAB
where A, B and C are matrices. Where elements can all be float, or can be double, or can be complex-float or can be complex-double. But all of the same type.
And A and B can be either not-transposed or transposed (in the complex case actually conjugated-or-transposed).
A call to this function looks like this when you use the Fortran Interface (GEMM is short for General Matrix Matrix Product, D indicates that elements and scalars all have double precision):
dgemm("N", "N", &m, &n, &k, &alpha, A, &lda, B, &ldb, &beta, C, &ldc);
Or through the C-Interface:
cblasdgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
So for computing C = A\*B you choose alpha=1 and beta = 0.
And you should only call it if A, B, C are not only different names but also refer so separate memory blocks.
So this is a very simple, almost primitive, interface.
And that’s what makes it great.
Because providing an efficient implementation (close to peak performance) is not that trivial. But with a narrow interface (e.g. all elements of the same type) at least feasible.
What you do in the implementation is not some Strassen algorithm. In short:
\- You compute the matrix product block-wise (so that you can exploit the cache hierarchy)
\- On the smallest block (that fit in the L1 cache) you apply architecture specific micro kernels
**Two world in one …**
Eigen actually does both. It provides matrix/vector classes and implements blocked matrix operations with platform specific micro kernels.
That’s great.
But still, I think it is of value to also have something which is a layer that brings them together.
ulmBLAS, for example, is kind of a prototype for this idea:
\- on top high-level libraries can be build
\- at the bottom the architecture specific stuff integrated
Back in 2016 (yes most of the code of ulmBLAS is from around 2014) I made experiments on how higher level libraries can make use of ulmBLAS:
\- [Boost.uBLAS](https://www.mathematik.uni-ulm.de/~lehn/testublas/) and
\- Blaze.
On the high-level part you can do crazy things, like matrix classes where elements are not stored in memory, but instead, computed when you access elements. And still, you can achieve a pretty good performance.
And other stuff like mixed element types. Where A, B, C, alpha, beta can have different types. So unless you make copies, you can’t do the operation with BLAS. But in the ulmBLAS layer you can deal with that when matrix blocks get packed and do the type promotions there with little overhead.
https://redd.it/1xhstgi
@r_cpp
slughorn: C++20 library implementing the Slug GPU vector-graphics technique
https://github.com/AlphaPixel/slughorn
https://redd.it/1xgxf38
@r_cpp
Billion-query-per-second lookup tables in C++
https://lemire.me/blog/2026/10/26/billion-query-per-second-lookup-tables-in-c
https://redd.it/1xgtw1k
@r_cpp
A faster way to compute signed 64-bit floor division by constants
https://www.benjoffe.com/fast-floordiv
https://redd.it/1xgnf6d
@r_cpp
Is loop unrolling one of the speed booster
Long story short, I tried to check performance of C++ vs python by checking if file exists.
Here after - naive loop unrolling, seems the C++ code speed boosted. Please suggest other hacks/suggestions to make C++ run faster. Also if any books, links, github - please. I request C++ professionals
import os.path
FILES_DIRECTORY : str = "data"
def missing_parser(_skip_index: int, _max_limit : int = 400):
_cur_index : int = _skip_index
_max_limit = _skip_index + 400
while _cur_index < _max_limit:
for j in range(_cur_index, _cur_index+100):
if os.path.exists(os.path.join(FILES_DIRECTORY, str(j)+".pkl")):
print("Path exists",str(j)+".pkl")
else:
print("Missing ",str(j)+".pkl")
_cur_index += 100
missing_parser(1)
real 0m0.750s
user 0m0.011s
sys 0m0.108s
#include<iostream>
#include<fstream>
#include<string>
#include<filesystem>
#define FILE_DIRECTORY = "data"
void check_files(unsigned _start, unsigned _end){
std::string file_name;
for(unsigned k=_start; k<=_end; k++){
bool file_exists = false;
std::string filename = "./data/"+std::to_string(k)+".pkl";
file_exists = std::filesystem::exists(filename);
if(file_exists){
std::cout<<"File Exists\n";
}else{
std::cout<<"File not exists\n";
}
}
}
int main(int argc, char const *argv[]){
check_files(1, 400);
return 0;
}
real 0m0.706s
user 0m0.004s
sys 0m0.080s
0.10 seconds. #include<iostream>
#include<fstream>
#include<string>
#include<filesystem>
#define FILE_DIRECTORY = "data"
void check_files(unsigned _start, unsigned _end){
std::string file_name;
for(unsigned k=_start; k<=(_end/10)+1; k++){
bool file_exists[10] = {0};
std::string filename1 = "./data/"+std::to_string(k)+".pkl";
std::string filename2 = "./data/"+std::to_string(k+1)+".pkl";
std::string filename3 = "./data/"+std::to_string(k+2)+".pkl";
std::string filename4 = "./data/"+std::to_string(k+3)+".pkl";
std::string filename5 = "./data/"+std::to_string(k+4)+".pkl";
std::string filename6 = "./data/"+std::to_string(k+5)+".pkl";
std::string filename7 = "./data/"+std::to_string(k+6)+".pkl";
std::string filename8 = "./data/"+std::to_string(k+7)+".pkl";
std::string filename9 = "./data/"+std::to_string(k+8)+".pkl";
std::string filename10 = "./data/"+std::to_string(k+9)+".pkl";
file_exists[k] = std::filesystem::exists(filename1);
file_exists[k+1] = std::filesystem::exists(filename2);
file_exists[k+2] = std::filesystem::exists(filename3);
file_exists[k+3] = std::filesystem::exists(filename4);
file_exists[k+4] = std::filesystem::exists(filename5);
file_exists[k+5] = std::filesystem::exists(filename6);
file_exists[k+6] = std::filesystem::exists(filename7);
file_exists[k+7] = std::filesystem::exists(filename8);
file_exists[k+8] = std::filesystem::exists(filename9);
file_exists[k+9] = std::filesystem::exists(filename10);
if(file_exists[k]){
std::cout<<k<<"File Exists\n";
}else{
std::cout<<"File not exists\n";
}
if(file_exists[k+1]){
std::cout<<k<<"File Exists\n";
}else{
std::cout<<"File not exists\n";
}
if(file_exists[k+2]){
std::cout<<k<<"File Exists\n";
}else{
std::cout<<"File not exists\n";
}
if(file_exists[k+3]){
std::cout<<k<<"File Exists\n";
}else{
std::cout<<"File not exists\n";
}
//so on, removed due to code length
}
}
int main(int argc, char const *argv[]){
check_files(1, 400);
return 0;
}
0.2 second. $ time command, real 0m0.512s
user 0m0.000s
sys 0m0.055s
Flecs 4.2 is out!
https://ajmmertens.medium.com/flecs-4-2-is-out-09435e80fdd1
https://redd.it/1xngu2n
@r_cpp
Pretty nasty MSVC 19.51 hash of float bug
Hash of 0.0 and -0.0 are not the same, as the condition:
_Keyval == 0.0F ? 0.0F : _Keyval
/arch:AVX2 /O2
New C++ Conference Videos Released This Month - November 2026
**C++Day**
2026-10-26 - 2026-11-01
* \[C++ Day 2026\] Old-School C++ for the Agentic Age: Lessons from Sane C++ (Stefano Cristiano) - [https://www.youtube.com/watch?v=tAf-HsET0pE](https://www.youtube.com/watch?v=tAf-HsET0pE)
* \[C++ Day 2026\] Zero-cost GIS: parsing binary formats in C++23 (Giorgio Bignotti) - [https://www.youtube.com/watch?v=VHeNHf6t76Q](https://www.youtube.com/watch?v=VHeNHf6t76Q)
**C++Now**
2026-10-26 - 2026-11-01
* AI is Forcing us to Obey Scott Meyers - Jody Hagins - [https://youtu.be/CiaZq4kCH08](https://youtu.be/CiaZq4kCH08)
* C++ Libraries - The Road Ahead - Jeffrey Garland - [https://youtu.be/bNipVnNaDdk](https://youtu.be/bNipVnNaDdk)
* Lightning Talk: ?: - Jonathan Müller - [https://youtu.be/TLj6NVx5xvk](https://youtu.be/TLj6NVx5xvk)
**ACCU**
2026-10-26 - 2026-11-01
* Creating Composable Callables in Contemporary C++ - Using Senders / Receivers as a Frame Graph - Björn Fahller - [https://youtu.be/A4mMO5xeQDA](https://youtu.be/A4mMO5xeQDA)
* Incrementally Migrating C++ to a Memory Safe Language with Swift - Tim Condon - [https://youtu.be/LMQ21X6\_2FQ](https://youtu.be/LMQ21X6_2FQ)
* CallMeMaybe - Building Modern Runtime Reflection via C++26 - Laurie Kirk - [https://youtu.be/cA0F3wRtZIU](https://youtu.be/cA0F3wRtZIU)
**ADC**
2026-10-26 - 2026-11-01
* TX/RX Part 2 - AI Audio on the Raspberry Pi - Kieran Coulter - [https://youtu.be/QSiyLDHoBpo](https://youtu.be/QSiyLDHoBpo)
* JUCE in DJ Products - Current Status and Future Prospects - Masamichi Tomii, Akihito Yamada & Tetsuro Abe - [https://youtu.be/VElORkcpE78](https://youtu.be/VElORkcpE78)
* Generative Instruments with Large Piano Models - Tomek Roszczynialski - [https://youtu.be/EO-hGj8\_BUY](https://youtu.be/EO-hGj8_BUY)
https://redd.it/1xm10uv
@r_cpp
C++20 Concept Trap of std::inserter and std::array
https://github.com/Jimmy-Hu/TinyDIP/discussions/2
https://redd.it/1xl06jo
@r_cpp
HPX V2.0.0 released: C++20 baseline, C++20 modules, stdexec-based senders/receivers, early C++26 reflection! - The HPX Project
HPX, the C++ Standard Library for Parallelism and Concurrency, has released V2.0.0. It is the largest release in a long time: more than 830 merged pull requests from more than 90 contributors since V1.11.0.
HPX implements the C++23 Standard parallelism and concurrency facilities in full and offers the only widely available open-source implementation of C++17, C++20, and C++23 parallel algorithms - including a complete set of parallel range-based algorithms and the full integration of the algorithms with the upcoming sender and receivers interfaces.
Beyond the standard, HPX includes proposed features for upcoming C++ releases: much of the parallelism and concurrency capabilities expected in C++26, the C++ Concurrency TS, Parallelism TS V2, data-parallel algorithms, executors, senders and receivers, and more. It also extends C++ Standard APIs to distributed environments (such as compute clusters) and heterogeneous systems (such as GPUs).
Some of the changes that may interest r/cpp:
* C++20 is now the minimum, and the whole library can optionally be built and consumed as C++20 modules.
* Our own std::execution implementation is gone; senders and receivers are now based on stdexec, and a P2079 parallel scheduler runs sender work on HPX thread pools.
* Early use of C++26 reflection: types can be serialized without writing serialize() functions, and remote actions and components no longer need registration macros.
* New C++23 parallel algorithms (the fold family, find\_last, iota) and many conformance fixes in the existing ones.
* Functions can carry a task size (nano\_task, small\_task, ...), which the parallel algorithms use to decide how to split a loop.
HPX enables an asynchronous C++ programming model that improves parallel efficiency and reduces the complexity typically associated with concurrent applications. As a newly welcomed project of the [High Performance Software Foundation](http://hpsf.io/), HPX now benefits from vendor-neutral governance and collaboration with a broader ecosystem of high-performance computing tools, strengthening the foundation for portable, production-ready HPC software across the industry.
Release: [https://github.com/TheHPXProject/hpx/releases/tag/v2.0.0](https://github.com/TheHPXProject/hpx/releases/tag/v2.0.0)
What's new: [https://docs.hpx.dev/latest/html/releases/whats\_new\_2\_0\_0.html](https://docs.hpx.dev/latest/html/releases/whats_new_2_0_0.html)
https://redd.it/1xkrq2q
@r_cpp
How do I avoid UB in contracts?
This question might be better served in /r/cpp_questions but since contracts were the reason C++26 failed the latest vote I thought posting it here might generate some useful debate.
I've been using contracts in personal projects since GCC16 was released. I've come to appreciate them both as documentation and in bug-finding. After the recent controversial vote I did have another look at them and their use in my code. Most of my contracts looks like the example in "3.5.5 Consecutive and Repeated Evaluations" of p2900:
```
void f(int *p)
pre( p != nullptr ) // precondition #1
pre( *p > 0 ); // precondition #2
```
This works as expected in `enforce`, `quick-enforce` and `ignore` evaluations. However if I use `observe` evaluation it'll crash with UB on the second precondition.
One fix is to merge the preconditions together `pre( p != nullptr && *p > 0)` which works in this case, but doesn't scale to for example classes where you'll have `pre( p != nullptr)` on the constructor and then assume it's valid for the rest of the body.
Another solution is to never use `observe` evaluation. This works in my applications where I control the build, but doesn't work in libraries used by others where I don't.
I wonder what my options here are?
*Edit* [Godbolt link](https://godbolt.org/z/c34bGabnf)
https://redd.it/1xk6lwk
@r_cpp
A useful way to handle keyboard and mouse input in C++ on Windows
If you're looking to create macros, remap keys, or simulate keyboard and mouse inputs in C++, you might find this useful.
I made Interceptor, a Windows kernel driver with a simple C++ SDK to send, intercept, and modify inputs.
https://github.com/TitanCSA/Interceptor
https://redd.it/1xjo8h0
@r_cpp
Euclid On-premise Cloud Services in C++
Euclid (Europeanne Cloud Initialive), has development an AWS like cloud service totally written in C++. It contains EQS (Queueing), ENS (publish/subscribe notifications), ESM (storage system) and many more.
Native compilable on Linux/Windows/macOS. Applications are running on a distributed system of worker hosts using an auto-scaler which distributes the work evenly.
Feature reuqests, bugs on https://github.com/jensvogt/euclid
https://redd.it/1xji7cy
@r_cpp
fb-cpp 1.0.0: A feature-complete modern C++ wrapper for Firebird
https://asfernandes.github.io/2026/09/04/fb-cpp-1-0-0
https://redd.it/1xjbhdi
@r_cpp
C++26, WG21, and ISO's national bodies
https://a4z.noexcept.dev/blog/2026/10/29/cpp26-wg21-and-isos-national-bodies.html
https://redd.it/1xit6qm
@r_cpp
What would it take to leave ISO?
With the conclusion of the DIS ballot, I think that no matter what side you're on, this should be (hopefully the final) wake up call that stayint in ISO under its process is untenable. If you're pro-contracts you probably see this as minority rule. If you're against, congrats-- the same game can be played against the feature you want in the future.
I see 3 possible results out of Brazil:
1. Contracts are pulled, fight to see another day and/or leave ISO, and/or fork the language.
2. Contracts stay, roughly as is. To my understanding FDIS is a final chance scenario, so I don't see this working out. Even "as a statement," it's not a good look and WG21 will eat the blame.
3. Contracts are fixed enough to flip 4 NB votes (there's a number of combinations, but you need a minimum of 4 total flips from no/abstain -> yes).
It's my understanding that FDIS is a "last chance" for 26. Personally, considering what else is in 26 (for me, reflection), I'd rather go with the first option. That begs the question: where do we go from here?
Continue with the current process, which has unearthed pain points and nasal demons every few years, or break up with the ISO process (this doesn't even have to be a clean break, just something closer to ECMAScript's process)?
If so, what would it take? Alternatively, if we could, what would we actually lose? What would we gain (besides more control of process)?
Obligatory "no sarcastic comments about getting a TARDIS and changing it back then."
https://redd.it/1xhcv4b
@r_cpp
Anyone Can Contribute to Boost: Demystifying C++ Maintainership | Arnaud Becheler - CppCon 2026
https://youtu.be/Nr7iV9w28cA
https://redd.it/1xgujv2
@r_cpp
Alternative C++ standard library
https://github.com/mov-rax-rbx/Alt
https://redd.it/1xgr4f5
@r_cpp
https://youtu.be/ttoQfPP\_Gkg
Design Patterns - The Most Common Misconceptions (3 of N) - Klaus Iglberger - [https://youtu.be/bAsJvmtYZOg](https://youtu.be/bAsJvmtYZOg)
One Lib to Rule Them All and in the Darkness bindgen… - Antonello Palazzi & Kay Hicketts - https://youtu.be/9BpVjPKv02s
ADC
2026-10-19 - 2026-10-25
Introducing LYDIA Phase2 - Kazuyoshi Sasamori, Alfie Bradic & Paul McCabe - [https://youtu.be/MyCMBiWAEqM](https://youtu.be/MyCMBiWAEqM)
FPGA-Based Alias-Free Oscillator - 岡安啓幸 / Akiyuki Okayasu - https://youtu.be/OXB5crrpFgc
Type-Erased Audio Parameters - A New Approach to an Old Problem - Jan Wilczek - [https://youtu.be/K-38Zpf13lQ](https://youtu.be/K-38Zpf13lQ)
2026-10-12 - 2026-10-18
Introduction of the Technologies That Make Up Project LYDIA - Taichi Kumon & Tom Baker - https://youtu.be/-Cyht3g4H1s
AI for Circuit Modeling - 村井 勝吾 / Shogo Murai - [https://youtu.be/IL08vd0EiFY](https://youtu.be/IL08vd0EiFY)
MIDI 2.0 - Ready to Ship - Brett g Porter - https://youtu.be/RGLtRZC--34
2026-10-05 - 2026-10-11
BEEPS and PORTS - Annoy Everyone in Your House While Building An Audio Synthesizer - Joseph Stewart - [https://youtu.be/bnIV2nyh-rg](https://youtu.be/bnIV2nyh-rg)
Hardware DSP Asset Inheritance and Evolution - Takeshi Kuwahara - https://youtu.be/yYukJpiFOOU
Field Recording - In Search for Perfect Sounds - Malin Arvidsson - [https://youtu.be/L5iZDi71VWU](https://youtu.be/L5iZDi71VWU)
2026-09-28 - 2026-10-04
Designing Interactive Music Experiences in XR - Kasson Crooker - https://youtu.be/J3sVHT8luKs
When (Not) to Patent Audio Software - Simon Hestermann - [https://youtu.be/stBB1JoKQiY](https://youtu.be/stBB1JoKQiY)
Distribution Strategies for Indie Audio Developers - From Plugin to Product - Dani Karanyi - https://youtu.be/Piar49uTjtg
https://redd.it/1xg0zqe
@r_cpp