-
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
Declaring bit fields with position as well as number of bits
I would love it if I could specify the bit position as well as the number of bits in a bit field, something like:struct S { uint32_t x : 0, 5; // Starts at position 0, size is 5 so goes up to position 4 uint32_t z : 18, 3; // Starts at position 18, size is 3 so goes up to position 20 uint32_t y : 5, 11; // Starts at position 5, size is 11 so goes up to position 15 }
Does anyone know if there are any proposals in the works to add something like this?
Of course there are many pitfalls (e.g. error/warn/allow overlapping fields?) but this would be useful to me.
I considered building some template monstrosity to accomplish something similar but each time I just fool around with padding fields.
https://redd.it/1nxnjqr
@r_cpp
Is C/C++ tooling and dependency management still a pain point in 2025?
Coming from modern ecosystems like JavaScript's npm/uv or Rust's Cargo, the experience with C++ build systems and package managers often feels... cumbersome. Tools like vcpkg and Conan exist, but is anyone else still frustrated with the overall workflow? Do we need a simpler, more intuitive approach, or have the existing tools solved these problems for you?
https://redd.it/1nx73wd
@r_cpp
Parallel C++ for Scientific Applications: Monte Carlo Methods
https://www.youtube.com/watch?v=FEkrPKaBE38
https://redd.it/1nx1c7k
@r_cpp
MyProtocol Web Server: Learn how to implement protocol over TCP
https://www.youtube.com/watch?v=GuNrcZTr0ds
https://redd.it/1nwu741
@r_cpp
C++ code
Anyone can guide to that how and from where to start c++ as a freshman in CS!!
https://redd.it/1nwszfd
@r_cpp
What's a C++ feature you avoided for years but now can't live without?
https://redd.it/1nwbcja
@r_cpp
A Month of Writing Reflections-based Code: What have I learned?
## Preface
I have been trying to automate writing my own pybind11 binding code with the help of C++26 reflections, as implemented by [clang-p2996](https://github.com/bloomberg/clang-p2996).
There were moments where things went smoothly, but also moments where I missed a feature or two from the world of reflections. Then there is also accidental complexity caused by pybind11 having features which are, at the very least, not friendly for generic binding generation.
Before I begin, a massive thanks to Barry Revzin, Daveed Vandevoorde, Dan Katz, Adam Lach and whoever else worked on bringing Reflections to C++.
## Smooth sailing
What we got from the set of reflections papers is awesome. Here's an example of what can be achieved quite easily:
https://godbolt.org/z/jaxT8Ebjf
With some 20 lines of reflections, we can generate bindings that cover:
- free functions (though not overload sets of free functions - more on that later)
- structs/classes with
- a default constructor
- member functions
- data members, though always writable from python
You can also see how this easily generalizes to all other kinds of `py_class.def_meow(...)`. Almost...
Since C++ does not have "properties" in the python sense, `def_property_meow` will need [special care](https://godbolt.org/z/MT5ojzG4n).
As the `def_property` example shows, customizing the generated bindings is possible with `[[=annotations]]`.
So far... this is AWESOME. Looks like we can make bindings for whatever C++ entity we fine.
Well, let's talk about the not so awesome parts of this adventure. In order from least troublesome to most troublesome
## Splicing ranges
Pybind11 likes to work with template parameter packs, but C++26 often leaves us with `std::vector<std::meta::info>`.
We can deal with this in multiple ways:
Options are:
- good old [`index_sequece`](https://godbolt.org/z/5vEM7dWhr)
- [structured bindings can introduce a pack](https://godbolt.org/z/GooGTsWdc)
- But constexpr structured bindings have not been implemented yet in clang-p2996
And one thing that didn't end up in [P2996](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2996r13.html#range-splicers) are [range splicers](https://godbolt.org/z/TPWqv3jss).
So this can be done. Depending on the context, it can even look elegant, but I often missed costexpr structured bindings and ended up reaching for `index_sequence` a lot.
Range splicers would have been nice, but I can live without them.
## Code duplication due to pybind11 design
Pybind11 has a lot of similar functions with different names:
`def` vs `def_static` vs `def_property` vs `def_property_readonly` vs ...
Then there are also things whose mere presence alters what pybind11 is doing, without a no-op state:
`is_final` for classes, `arithmetic` for enums and so on.
These can be handled with an `if constexpr` that branches on existence of annotation, however, this leads to a lot of code duplication.
Here, token sequences as described in https://wg21.link/P3294 would remove most of repetition. For the `def_meow` stuff, an approximate reduction in amount of code is ~10x.
## Pure virtual bases
To use these with pybind11, users need to write ["trampolines"](https://godbolt.org/z/ffPKE7Gxb), because it needs to be able to instantiate a python object representing the base class object.
C++26 still can't generate types that have member function, but this will be solved with https://wg21.link/P3294
## Templates can't be annotated
It would be useful to annotate member function templates with something like
template_inputs({
{.name = "T1Func", .args = {^^T1}},
{.name = "T2T3Func", args = {^^T2, ^^T3}}
})
And then bind the same template multiple times, under different names and with different template arguments. However [that's not possible right now](https://godbolt.org/z/qx5c1v417). Can templates even have attributes and annotations?
## Function parameter missing features
**Parameter annotations can
Understanding Modern C++ 23 Features in real world scenarios
https://drive.google.com/file/d/1X__JUjZOAXVIUPuBaGCrN_h1dlu7Vxe8/view?usp=drivesdk
https://redd.it/1nvyhmw
@r_cpp
Compiler optimization is amazing, but not for std::generator
https://godbolt.org/z/3ecMG7W3n
https://redd.it/1nvxf4q
@r_cpp
C++ Show and Tell - October 2025
Use this thread to share anything you've written in C++. This includes:
* a tool you've written
* a game you've been working on
* your first non-trivial C++ program
The rules of this thread are very straight forward:
* The project must involve C++ in some way.
* It must be something you (alone or with others) have done.
* Please share a link, if applicable.
* Please post images, if applicable.
If you're working on a C++ library, you can also share new releases or major updates in a dedicated post as before. The line we're drawing is between "written in C++" and "useful for C++ programmers specifically". If you're writing a C++ library or tool for C++ developers, that's something C++ programmers can use and is on-topic for a main submission. It's different if you're just using C++ to implement a generic program that isn't specifically about C++: you're free to share it here, but it wouldn't quite fit as a standalone post.
Last month's thread: https://www.reddit.com/r/cpp/comments/1n5jber/c_show_and_tell_september_2025/
https://redd.it/1nvqyyi
@r_cpp
A FastApi-style framework for Cpp
Hello everyone, I am trying to make something similar to fastapi.
So far I’ve implemented:
* Header-only design (just include one header to get started)
* FastAPI-style route definitions with `APP_GET` / `APP_POST` macros
* Automatic parsing of path params and JSON bodies into native C++ types or models
* Validation layer using nlohmann::json (pydantic like)
* Support for standard HTTP methods
Due to lack of reflection in cpp, working on few parts was somewhat challenging to me as a beginner. It’s still early-stage and experimental, but I’d love guidance, feedback, and contributions from the community.
Repo:- [https://github.com/YashArote/fastapi-cpp](https://github.com/YashArote/fastapi-cpp)
https://redd.it/1nvjqxe
@r_cpp
Is C++ still worth learning when job listings barely mention it?
Lately I’ve been scrolling through job boards. Backend, full-stack, AI, cloud- lots of Python, Go, Rust. C++ roles are rare. I wonder if it’s just my region or everyone’s seeing the same fade.
When I interviewed last month for a systems role, they asked me to explain move semantics and lifetime of temporaries. I squeezed something about rvalue references, but in my head I was screaming: “Does any company still care about this in production?” Yet later I saw a Reddit thread saying C++ is still heavy in finance, embedded, robotics, and high-performance domains.
A senior dev told me this: “If you can speak templates, memory models, threading without fear, you’ll outshine those who only know high-level stuff.” That stuck. In another interview, they were debugging a segfault on a server-side C++ service, and my ability to trace through stack frames won me half points—even though the role didn’t emphasize “C++” in the title.
Still, many listings say “experience in C++ is a plus” rather than a requirement. It feels like a framing issue. (Maybe “systems, performance, low latency” are the real signals.) If I were writing a resume now, I’d show a toy project- say a small event loop + custom allocator- or contribute to a performance-critical open source piece. That gives a talking point in interviews beyond just “I studied C++ in school.”
I don’t mean to say C++ guarantees a job, but in some corners, it still feels like a secret weapon.
https://redd.it/1nv7tfd
@r_cpp
Unreal Engine
I’ve already learned C++ (including concepts like DSA and OOP), and now I want to start learning Unreal Engine. My main doubt is: how different is the C++ I’ve learned from the C++ used in Unreal Engine? Specifically, I’m wondering if the syntax and keywords are the same, or if Unreal has its own version of C++ that I need to learn separately. In other words, can I directly apply the C++ I already know inside Unreal, or should I relearn C++ specifically for Unreal Engine? Iam really confused right now!!!!! 😕
https://redd.it/1nv4vba
@r_cpp
More speculations on arenas in C++
https://nullprogram.com/blog/2025/09/30/
https://redd.it/1nuhosj
@r_cpp
How to store password for database connection?
I just started learning C++ in school and want to expand one of my projects. I’ve set up a PostgreSQL database and connected it to C++ by hardcoding the username, password, and other details. I’ve been trying to figure out how to securely store this sensitive information, and I came across the idea of using environment variables. I’m looking for resources or tips on how to implement this.
https://redd.it/1nuei7m
@r_cpp
Undefined Behavior From the Compiler’s Perspective
https://youtu.be/HHgyH3WNTok?si=8M3AyJCl_heR_7GP
https://redd.it/1nxmlv3
@r_cpp
Can someone explain this
So im doing Socket programing in C using winsoc2 and im donw with my server-socket now im programing my client-socket but i dont get this :
\#define DEFAULT_PORT "27015"
// Resolve the server address and port
iResult = getaddrinfo(argv[1\], DEFAULT_PORT, &hints, &result);
if (iResult != 0) {
printf("getaddrinfo failed: %d\\n", iResult);
WSACleanup();
return 1;
}
https://redd.it/1nx5arl
@r_cpp
C++26: std::optional<T&>
https://www.sandordargo.com/blog/2025/10/01/cpp26-optional-of-reference
https://redd.it/1nwxe0x
@r_cpp
The problem with inferring from a function call operator is that there may be more than one
https://devblogs.microsoft.com/oldnewthing/20251002-00/?p=111647
https://redd.it/1nwtv47
@r_cpp
Eigen 5.0.0 has been quietly released
https://gitlab.com/libeigen/eigen/-/releases/5.0.0
https://redd.it/1nwfjc8
@r_cpp
not be queried: https://godbolt.org/z/r19185rqr**
Which means one can not put a hypothetical `noconvert(bool)` annotation on a parameter for which one would not like implicit conversions on the python side. (Or rather, one can not find the annotation with `annotations_of()`).
The alternative is to annotate the function with an array-like list of indices for which implicit conversions are undesirable. This is a pretty error prone option that is brittle in the face of refactoring and signature changes.
I know that annotations and function parameter reflections have moved through WG21 in parallel and hence the features don't work with one another, but annotating parameters would be quite useful.
**Parameter reflections can't give us default values of the reflected parameter**
This is a can of worms. Default values need not be constant expressions, need not be consistent between declarations, and [can even "stack"](https://godbolt.org/z/Ycf9hdxxr).
However, the lack of ability to get some sort of reflection on the default value of a parameter paints us in a corner where we have to bind the same function multiple times, always wrapped in a lambda, to emulate calling a function with different number of arguments.
Here's an example: https://godbolt.org/z/Yx17T8fYh
Binding the same function multiple times creates a runtime overload set, for which pybind11 performs runtime overload resolution in a case where manual binding completely avoids the runtime overloading mechanisms.
Yes, my example with `int y = 3` parameter is very simple and avoids all the hard questions.
From where I stand, it would be enough to be able to splice a token sequence matching the default argument value.
There is a case that I don't know how I'd handle: https://godbolt.org/z/Ys1nEsY6r
But this kind of inaccessible default parameters could never be defaulted when it comes to pybind11.
## Conclusion
C++26 Reflections are amazing and the upcoming token sequences would make it even more so.
Still, there is a thing or two that I have not noticed is in planning for C++29. Specifically:
- Function parameter annotations and reflection of default values would be extremely useful. If there's one thing I'd like to get in the future, it's this one.
- Range splicers, of the form `[:...range:]` would clean up some things too.
- Template annotations as a distant 3rd for automatically generating bindings for template instantiations.
So that I don't end on a note that might look entitled, once again, a sincere thank you to everyone involved in C++ Reflections.
EDIT1: Fixed sloppy wording when it comes to parameter annotations.
https://redd.it/1nw39g4
@r_cpp
StockholmCpp 0x39, Intro, host presentation, community news and a quiz
https://youtu.be/a89UyDRWbkg
https://redd.it/1nw07w2
@r_cpp
Herb Sutter blog:My other CppCon talk video is now available: The Joy of C++26 Contracts (and Some Myth-Conceptions)
https://herbsutter.com/2025/10/01/my-other-cppcon-talk-video-is-now-available-the-joy-of-c26-contracts-and-some-myth-conceptions/
https://redd.it/1nvxb8m
@r_cpp
The problem with Object Oriented Programming and Deep Inheritance
https://youtu.be/V372XIdtOQw
https://redd.it/1nvrv21
@r_cpp
C++ code styles used by JetBrains devs
CPP code styles topic has probably been beaten to death, and there is 0 agreement on what is considered a right choice.
Many blindly pick Google simply because of the name, however more experienced say that it is highly controversial and evolved from the huge legacy code base (e.g. if you have large 4k monitors reading Google c++ code styles with 2 space indentation and 80 characters lines it's like reading a book in the middle of the screen).
CLion offers the styles listed below, I am curious what JetBrains C++ devs use themselves?
* Google
* LLDB
* LLVM
* Microsoft
* QT
* STL
* Stroustrup
https://redd.it/1nvjgus
@r_cpp
C or C ++
Hey, im a intermediate dev and i want to learn a new language that will be useful for the mort of the things i want to do. I know python because it's a must have especially because im interested in machine and Deep learning but also in Cybersecurity. That's why i hésitate between C and C ++ cause i want to learn a low level language and i want the most easy one. If you can help me 🙏
https://redd.it/1nvffw7
@r_cpp
How to effectively read "Programming: Principles and Practice Using C++" by Bjarne Stroustrup?
Hey everyone,
I recently got a copy of "Programming: Principles and Practice Using C++" by Bjarne Stroustrup (the creator of C++ himself), and I'm feeling a bit overwhelmed. The book is over 1,200 pages long and seems quite academic in its approach.
I'm planning to use it for self-study, but I have a few questions:
1. Is this book suitable for self-study?
Given that it's an academic textbook, I'm wondering if it's practical to work through it on my own without a structured course or instructor guidance.
2. How should I approach reading it effectively?
Should I:
•Read it cover to cover?
•Skip certain chapters initially?
•Focus more on the exercises than the theory?
•Supplement it with other resources?
3. How long did it take you to complete it?
For those who've finished it, what was your study schedule like?
4. Any tips for staying motivated through 1,200+ pages?
I have some basic programming knowledge but I'm relatively new to C++. Any advice from those who've tackled this book would be greatly appreciated!
Thanks in advance!
https://redd.it/1nv6ot3
@r_cpp
abi checker for libraries
I would like to verify that my library does not change API/ABI. I want a tool that can load headers+binaries and generate json/xml representation of the public API/ABI. Then - I would like an option to generate a list of added/removed interfaces from a saved file.
I only found https://github.com/lvc/abi-compliance-checker but seems outdated.
https://redd.it/1nukpn3
@r_cpp
GREATEST language ever
https://youtube.com/shorts/dyQDP2dn-ms?feature=share
https://redd.it/1nuguc4
@r_cpp
zerialize: zero-copy multi-protocol serialization library
Hello all!
github.com/colinator/zerialize
I'd like to present 'zerialize', a zero-copy multi-dynamic-protocol serialization library for c++20. Zerialize currently supports JSON, FlexBuffers, MessagePack, and CBOR.
The main contribution is this: zerialize is fast, lazy and zero-copy, if the underlying protocol supports it.
Lazy means that, for supporting protocols (basically all except JSON), deserialization is zero-work - you only pay when actually reading data, and you only pay for what you use.
Zero-copy (again, for all but JSON) means that data can be read without copying from bytes into some structure. This zero-copy ability comes in handy when deserializing large structures such as tensors. Zerialize can zero-copy deserialize blobs into xtensor and eigen matrices. So if you store or send data in some dynamic format, and it contains large blobs, this library is for you!
I'd love any feedback!
https://redd.it/1nuayda
@r_cpp