-
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
The Best C++ online compiler
Compiler Explorer is a highly popular online C++ compiler that can be used to test various compilation and execution environments or share code. As a C++ enthusiast, I interact with it almost daily, and its usage frequency far exceeds my imagination. At the same time, I am a heavy user of VSCode, where I complete almost all tasks. Considering that I often write code locally and then copy it to Compiler Explorer, I always feel a bit uncomfortable. Sometimes, I even make changes directly in its web editor, but without code completion, it's not very comfortable. So, I developed this plugin, Compiler Explorer for VSCode, which integrates Compiler Explorer into VSCode based on the API provided by Compiler Explorer, allowing users to directly access Compiler Explorer's functionality within VSCode.
https://marketplace.visualstudio.com/items?itemName=ykiko.vscode-compiler-explorer
https://redd.it/1ccnd5l
@r_cpp
When and how variables are initialized? - Part 3
https://www.sandordargo.com/blog/2024/04/24/initializations-part-3
https://redd.it/1ccl9wu
@r_cpp
Templates View for Build Insights in Visual Studio - C++ Team Blog
https://devblogs.microsoft.com/cppblog/templates-view-for-build-insights-in-visual-studio-2/
https://redd.it/1cc33df
@r_cpp
accumulate, reduce, and fold
https://biowpn.github.io/bioweapon/2024/04/23/accumulate-reduce-fold.html
https://redd.it/1cbwl8q
@r_cpp
C++26* / P2996 Implementing static reflection proposal with the static reflection proposal (the meta-programming part)
Reflection for C++ proposal - (https://wg21.link/P2996) - is very powerful. It also supports stateful meta-programming which ironically allows to implement (at least partially) the meta-programming model of the proposal itself (meta meta-programming).
The following is the implementation which allows to accomplish most meta-programming tasks with or without using ranges based on that premise. The basic idea is to add new instantiations of metainfo<id> aka mapping from id to type for given type with meta<T> (\^lift operator in P2996). Then ids can be manipulated in the immediate context with ranges/algorithms/etc. Upon completion we can go back to types by applying typeof for computed ids.
Disclaimer: It's just to demonstrate the potential of P2996 and that it's possible with C++17+.
namespace detail {
template<class T> struct typeinfo { using type = T; };
template<info i> struct idinfo { static constexpr info value = i; };
template<info> struct metainfo; // [not defined] it will be injected by defineclass with typeinfo and idinfo
template<class T> consteval auto meta() { // add to the global id-type mapping and return id so that it can be manipulated with algorithms
for (std::sizet i{};; ++i) { // infinite loop as we are looking for incomplete metainfo instantiations
if (auto meta = std::meta::substitute(^metainfo, {std::meta::reflectvalue(i)});
std::meta::isincompletetype(meta)) { // when we find not instantiated metainfo we add a new version with mapping to the id
return std::meta::defineclass( // boilerplate to inject into metainfo
std::meta::substitute(^metainfo, {std::meta::reflectvalue(i)}),
{std::meta::datamemberspec(^typeinfo<T>, {.name="type"}),
std::meta::datamemberspec(substitute(^idinfo, {std::meta::reflectvalue(i)}), {.name="id"})}
);
}
}
}
template<info i> consteval auto typeof() {
return std::meta::substitute(^metainfo, {std::meta::reflectvalue(i)}); // just get the instantiated metainfo for given id
}
} // namespace detail
template<class T>
inline constexpr auto meta = typename : detail::meta<T>() :{}.id.value; // returns metainfo (in our case just an id)
template<info i>
using typeof = decltype(typename : detail::type_of<i>() :{}.type)::type; // gets the type of given id
template<template<class...> class T, auto Expr> // goes through all ids and gets their types
using applyt = decltype([]<std::sizet... Ns>(std::indexsequence<Ns...>){
return T<typeof<ExprNs>...>{};
}(std::makeindexsequence<Expr.size()>{}));
> examples without ranges
template<std::sizet N, class... Ts>
using at = typeof<std::array{meta<Ts>...}N>;
staticassert(typeid(int) == typeid(at<0, int, float, double>));
staticassert(typeid(float) == typeid(at<1, int, float, double>));
staticassert(typeid(double) == typeid(at<2, int, float, double>));
> examples with ranges
template<class...> struct typelist { };
template<class... Ts>
using reverse = applyt<typelist, std::array{meta<Ts>...}
| std::views::reverse
| std::ranges::to<vector>()>;
staticassert(typeid(typelist<double, float, int>) == typeid(reverse<int, float, double>));
Full example -> https://godbolt.org/z/694e1hrbM
The meta-programming model is possible to implement in C++17+ - https://github.com/boost-ext/mp
Updates -> https://twitter.com/krisjusiak/status/1783103406523007196
https://redd.it/1cbwjcu
@r_cpp
How to quickly factor out a constant factor from integers
Hi,
I was thinking of how to simplify trailing zero removal from my Dragonbox algorithm, came up with a divisibility check algorithm which seems to be novel, and decided to write a post about it and other existing algorithms. Hope you find it interesting!
Link to the post: https://jk-jeon.github.io/posts/2024/04/how-to-quickly-factor-out-a-constant-factor/
Link to the benchmark repo: https://github.com/jk-jeon/rtz\_benchmark
https://redd.it/1cbsobb
@r_cpp
Is manually implemented memory pool still necessary when using jemalloc?
jemalloc provides a really good mechanism to manage small objects and emphasizes fragmentation avoidance.
The purpose of memory pool is mainly about fast allocation, avoiding fragmentation. jemalloc can handle it really well.
Besides, the performance of manually implemented memory pool is largely depend on ability of module developers.
So it seems unnecessary to implement memory pool manually when using jemalloc in project.
https://redd.it/1cbnyej
@r_cpp
Announcing YOMM2 1.5.0 + talk at using std::cpp
YOMM2 1.5.0 has been released. This version contains substantial new
functionality. In particular, it makes it possible to use custom RTTI systems
(see the custom RTTI
tutorial).
Under some restrictions, YOMM2 can even be used without RTTI at all, and with
non-polymorphic types (see example
here).
This is achieved through the new
_policy_
mechanism, which provides a series of facets that YOMM2 delegates to, in
various parts of its operation.
It is now possible to customize how YOMM2 locates the virtual function table for
an object. For example, a class hierarchy can collaborate with YOMM2 by carrying
the vptr in the object (this is how YOMM11 worked). See the documentation of
vptr_placement
for an example that demonstrates how to use a single vptr per page of objects.
YOMM2 is, by default, exception agnostic, and reports errors by calling a
function and passing it a std::variant. This can be changed by replacing theerror_handler facet of a policy; for example, the throw_error implementation
throws the content of the variant as an exception.
The existence of trace for the runtime is now documented (although its exact
format is only specified as "useful").
In an ongoing effort to reduce memory footprint when it matters, it is possible
to disable the error diagnostics. Also, the standard iostream library is not
used anymore.
## Release notes
Document policies and facets, enabling:
use of custom RTTI systems (or no RTTI at all)
configurable placement of virtual table pointer
configurable hash function
configurable error reporting (call std::function, throw exception)
tracing the construction of dispatch tables
Document error classes completely.
Use lightweight version of ostream by default
Convenience macro YOMM2_STATIC
vcpkg integration (thanks to Fabien Pean) and
example
## YOMM2 @ using std::cpp
I will give a talk about YOMM2 at the using std::cpp
conference,
taking place at the Universidad Carlos III de Madrid, on April 24, at 18:30,
local time.
I am particularly interested in one of the talks: Perfect Hashing in an
Imperfect World, by Joaquín M. López Muñoz, because YOMM2 uses that.
---
YOMM2 is a C++17 library that implements fast, open multi-methods. It is
inspired by the papers by Peter Pirkelbauer, Yuriy Solodkyy, and Bjarne
Stroustrup. Open methods are like virtual functions, but they typically exist
outside of classes, as free functions. This effectively solves the Expression
Problem, and makes the Visitor Pattern obsolete. In addition, open multi-methods
can have any number of virtual parameters (aka multiple dispatch).
YOMM2 is available on GitHub,
vcpkg and Compiler
Explorer.
https://redd.it/1cbe4kp
@r_cpp
CppCast: Pure Virtual C++
https://cppcast.com/pure_virtual_cpp/
https://redd.it/1cbd879
@r_cpp
Handling code variability
Hi everyone,
I came across a very large subject at work.
My team and I work on a relatively large distributed system, build upon multiple components, communicating to each other through a data bus.
We can instantiate or not a component, depending on deployment type we want.
The overall can see a product line, each project is a specific instance of this product line. This is the product view.
Now, handling this variability inside the code is relatively difficult, because of legacy, lack of visions, of tools, …
When speaking of variability, I mean something like « In this deployment type, this component should send this type of data », or « this component should start this monitoring thread in that case only », …
Of course our stack is C++ only and I ask this question only here because we need to answer that subject with methods that work with such language.
Would you rather handle this in #ifdef ?
In something more flexible and efficient ?
Do you handle variability at compile-time, at runtime ?
I’ve got a lot of question on that matter and expect to find some variability and product lines experts who can redirect me to good littérature !
Thanks for your reading time !
https://redd.it/1cbcxte
@r_cpp
Noisy: The Class You Wrote a Hundred Times
For code exploration purposes, you probably wrote at least once a class that prints a message in its constructors, its destructor, and its copy and move operations. And like me, you probably wrote it multiple times. I decided to write it well once and for all, and share it on GitHub.
GitHub: https://github.com/VincentZalzal/noisy
I also wrote a blog post about it: https://vzalzal.com/posts/noisy-the-class-you-wrote-a-hundred-times/
https://redd.it/1cb2b19
@r_cpp
How to know if I should have more ASIO ioservice?
I have a Linux application that uses Boost ASIO to communicate over TCP to upto 10000 servers in async way.
Currently, I call \`io\service.run()` from 8 threads(host size is 4 core, 16GB) to process IO to/from peers.
I know internally, ASIO would use `epoll` on single fd for the io_service.
I wanted to know how to understand if having a single io_service, albeit spread across multiple threads, could be a potential bottleneck.
Is io_service, only limited by epoll?
Note: changing application to use multiple io_service is bit involved, hence could not do a quick POC as of now.
https://redd.it/1caw0xt
@r_cpp
Visualization library/framework for C++ ball collision simulation
I am currently writing a project about ball collision simulation. I need a C++ library to visualise the project. I have a number of balls between 0-100. I have the x,y coordinates of these balls at any time and their velocities in x,y planes. Is it possible to visually track the movement of the balls over time?
I looked for a library but I couldn't find one. I'm looking for a helper to visualise my program.
https://redd.it/1cagi36
@r_cpp
C++ socket programming idea
Hello guys! So, i want to make a tool written in C++ that does the subnetting of a network and sets the corresponding ip and mask on every (suppose) linux host in the network.
Functionality: Suppose we a are a host in a LAN and we want to configure all the other linux hosts given an ip and a subnet mask as input. We run the app on our machine and broadcast every other host with their corresponding ip/mask. The other hosts listen and receive their packet, process the data and configure their physical port with the ip/mask sent by us.
I assume i will have to use socket programming and multithreading so that the program has a server component (the linux machine initialing the configuration, our machine in the example above) and a client component (all the other hosts will listen for their ip/mask configuration). There should also be a network discovery mechanism(using broadcast communication i assume) so that the server finds out the number of the hosts in the network.
Questions:
Is there a better architecture/working principle than the one described by me?
I think that python would be more appropriate for this kind of stuff but i choose c++ because i want to make this project for hiring as a c++ developer. correct me if i am wrong pls
MAIN QUESTION:
How do i test this? Is there some kind of tool where i can simulate a simple lan(only 2-3 linux hosts) and run my c++ project and check weather the ips are set correctly? Some kind of packet tracer or ns3 where i can upload my project on a simulated LAN. Thanks!
https://redd.it/1cahhnk
@r_cpp
C++ Videos Released This Month - April 2024 (Updated to Include Videos Released 04/15/2024 - 04/21/2024)
This month the following C++ videos have been published to YouTube. A new post will be made each week as more videos are released
CppCon
04/15/2024 - 04/21/2024
Lightning Talk: Help! My Expression Template Type Names Are Too Long! - Braden Ganetsky - [https://youtu.be/YKWBNzjmBvg](https://youtu.be/YKWBNzjmBvg)
Lightning Talk: Spanny: Abusing C++ mdspan Is Within Arm’s Reach - Griswald Brooks - https://youtu.be/FZZ3CDnBEx4
Lightning Talk: C++ and the Next Generation: How to Support Women and Families in Tech - Sara Boulé - [https://youtu.be/t2H3-J2drvg](https://youtu.be/t2H3-J2drvg)
Lightning Talk: Filling the Bucket: Reading Code, C++ Code Interviews & Exams - Amir Kirsh - https://youtu.be/ju189bWGNmY
Lightning Talk: Write Valid C++ and Python in One File - Roth Michaels - [https://youtu.be/GXwYjI9cJd0](https://youtu.be/GXwYjI9cJd0)
04/08/2024 - 04/14/2024
Lightning Talk: The Power of Silence and Music in Agile Software - Valentina Ricupero - https://youtu.be/cPKbQOEqAVU
Lightning Talk: ClangFormat Is Not It - Anastasia Kazakova - [https://youtu.be/NnQraMtpvws](https://youtu.be/NnQraMtpvws)
Lightning Talk: A Fast, Concurrent Data Loader for Time-Series Data - Glenn Philen - https://youtu.be/rsERMD9jUNE
Lightning Talk: Un-Undefining Undefined Behavior in C++ - Jefferson Carpenter - [https://youtu.be/S49fKs0Bv1Q](https://youtu.be/S49fKs0Bv1Q)
Lightning Talk: Interfaces in C++ - Megh Parikh - https://youtu.be/zPudH\_y4OXo
04/01/2024 - 04/07/2024
Lightning Talk: Implementing Coroutines Using C++17 - Alon Wolf - [https://youtu.be/ULJcnSTwg9g](https://youtu.be/ULJcnSTwg9g)
Lightning Talk: Introverts: Speak! - Rudyard Merriam - https://youtu.be/EvDh19wWDOo
Lightning Talk: Constraining Automated Trading Risk with Linux Signals - Max Huddleston - [https://youtu.be/\_HGQ\_8cr0sY](https://youtu.be/_HGQ_8cr0sY)
Great C++ is_trivial: trivial type traits - Jason Turner - https://youtu.be/bpF1LKQBgBQ
Better CMake: A World Tour of Build Systems - Better C++ Builds - Damien Buhl & Antonio Di Stefano - [https://youtu.be/Sh3uayB9kHs](https://youtu.be/Sh3uayB9kHs)
All of these talks can also be accessed at [https://cppcon.programmingarchive.com](https://cppcon.programmingarchive.com) where you can also find information on how to get early access to the rest of the CppCon 2023 lightning talks.
Audio Developer Conference
04/15/2024 - 04/21/2024
Making It Good (the Principles of Testing Hardware and Software) - Emma Fitzmaurice - https://youtu.be/TYXPLdN7awA
Confluence of Code and Classical Music: Ragas, Bach & Sonic Pi - Nanditi Khilnani - [https://youtu.be/DCYM5\_VjC4Y](https://youtu.be/DCYM5_VjC4Y)
04/08/2024 - 04/14/2024
Real-Time Inference of Neural Networks: A Guide for DSP Engineers - Valentin Ackva & Fares Schulz - https://youtu.be/z\_RKgHU59r0
Modular Audio Synthesis on FPGAs With the High Level Synthesis Development Flow - Aman Jagwani - [https://youtu.be/gAZGuwggAQA](https://youtu.be/gAZGuwggAQA)
Reactive Embedded Programming - Tom Waldron - https://youtu.be/FUX4os7QZgc
04/01/2024 - 04/07/2024
Build a High Performance Audio App With a Web GUI & C++ Audio Engine - Colin Sullivan & Kevin Dixon - [https://youtu.be/xXPT8GAEozs](https://youtu.be/xXPT8GAEozs)
Procedural Sound Design Applications - From Embedded to Games - Aaron Myles Pereira - https://youtu.be/Da6mDLrOGok
Embedded Software Development - A Wild Ride! - Matt Speed & Andy Normington - [https://youtu.be/xr8fSJ2Uw1A](https://youtu.be/xr8fSJ2Uw1A)
Meeting C++
04/01/2024 - 04/07/2024
C++20's Coroutines for Beginners - Andreas Fertig -
How hard has your experience been while trying to find a Modern C++ Job?
I recently went through a series of interviews with Qualcomm for a modern C++ role, and I've hit a roadblock.
About 2.5 months ago, Qualcomm approached me via LinkedIn, and I was clear from the outset that I would only consider the opportunity if my salary expectations were met.
Despite numerous discussions and assurances from the recruiter, after completing all interview rounds, Qualcomm offered me only half of my expected salary.
Before each interview round, I explicitly stated that I wouldn't proceed if my salary expectations couldn't be met, yet each time, I was assured they would be.
What's particularly frustrating is that I have all starting conversations documented on LinkedIn, where I emphasized NOT TO proceed with my resume if the salary expectations couldn't be met. I can share screenshots of these conversations, demonstrating my clear stance right from the beginning.
Has anyone else encountered a similar situation?
This is specific to Modern C++, because I don't see it happening to other developers of other programming languages.
Are there far too many to choose from?
https://redd.it/1ccnc8w
@r_cpp
A Tour of the IFC SDK: Tools for a C++ Module Format
https://youtu.be/t6QCzVXrwIw?si=1awdFhUDV9a0DTZX
https://redd.it/1ccke9i
@r_cpp
Live function runtime visualization in Visual Studio
https://youtu.be/3PnVG49SFmU?si=WhGTbLCS4NOGS_TJ
https://redd.it/1cc0jg4
@r_cpp
Setting up new C++ projects always overwhelms me as hell so I decided to create yet another project initializer... (inspired by the JS ecosystem)
https://github.com/painfulexistence/create-cxx
(Any feedbacks/suggestions or even PRs are welcomed!)
I know there are nice existing tools and templates like cmake-init and cmake-template, but I found them a bit too general when you already know what kind of projects you're gonna be creating and what toolset you're gonna be using.
So, inspired by the awesome create-vite from the JS ecosystem, I decided to create this tool to meet my own needs. Here's what it offers:
Features
Interactive prompts guide you through setting up new projects
Choose from a handful of templates
CMake and vcpkg ready
Do everything via CLI, eliminating the need to copy templates from GitHub
Easy installation and use:
​
npx create-cxx <project_name>
License
MIT - so you can fork this to customize the tool and make your own templates
​
Though I've talked a lot about the tool, the key takeaway here isn't the tool itself (I certainly hope that it can help someone in the C++ community). Rather, it's about the idea that sometimes it's really beneficial for C++ developers to borrow workflows from other ecosystem to create convenient tools that solves our own pain points.
This custom tool has significantly boosted my productivity, I wish you can also find your best tool for your own workflow, cheers 🍻
https://redd.it/1cbwyr1
@r_cpp
How To Create Simple Generative AI Code In C++
https://learncplusplus.org/how-to-create-simple-generative-ai-code-in-c/
https://redd.it/1cbtrl4
@r_cpp
Looking for switch in c++ domain
I am having 1 year of professional experience, and 3 month internship.
Currently I am working organization works on creating Android application development in Java.
I have experience in backend development using python (flask), nodejs, express.js.
I am familiar with c++ language with oops concept and STL.
I am having non-cs background, can you please suggest some projects or topics I should study before going for interview on cpp related jobs. Also is what domain I.e gaming, hardware, drivers, etc should I target which requires cpp after my current experience.
If there is any valuable feedback please share the same.
Thanks in advance!
https://redd.it/1cbrm71
@r_cpp
Where is unistd.h implemented?
This may seem like a weird Question asked by a Semi-Beginner.
I have searched for the implementation of the write function from unistd.h, because I wanted to search for the lowest level way to make a syscall to write to stdout without using actuall inline assembly. And then I was not able to find any implementation. I also heard that unistd.h is not a part of the standard C library. So my question is: where is it implemented?
https://redd.it/1cblhse
@r_cpp
Is the STL 100% reconstructable?
My Question is essentially, if the Standard Template Library is completely recreatable with just a C++ compiler and without modifying said compiler.
**How I came up with this Question**
I recently tried to recreate the class `std::initializer_list` and found out that even if I copy the exact definition from the `<initializer_list>` header file, the std class behaves different than my custom one.
On another occasion I learned about 'structured bindings' ( C++17, [https://en.cppreference.com/w/cpp/language/structured\_binding](https://en.cppreference.com/w/cpp/language/structured_binding) ), which allow for direct extraction from a tuple like this:
auto[var1, var2] = get_tuple(val1, val2);
But if you want to recreate this behaviour for your own types you have to overload `std::tuple_size` and `std::tuple_element`.
I dont really get why `std::tuple` as well as `std::initializer_list` seem to be backed by the compiler. Especially because `std::initializer_list` seems to have only cosmetic features backed.
https://redd.it/1cberi5
@r_cpp
My guide on optimizing C++ code
https://uchenml.tech/optimizing-linear/
https://redd.it/1cbdv36
@r_cpp
Processor Instructions
Why do some programs and OS require newer instructions like SSE 4.2 and AMX, while others do not require these instructions and function normally in the same way, performing the same tasks?
I understand that in the beginning, 16-bit or 32-bit instructions had RAM limitations, but after the release of 64, it's usually the same thing regarding RAM.
An example is Windows 11, the 24H2 version will require POPCNT, but the current 23H2 does not require this, and works normally. This requirement has nothing to do with AI, as the 24H2 will have AI capabilities exclusive to NPU processors. Additionally, some AI functions are already being backported to 23H2.
https://redd.it/1cb46ps
@r_cpp
Representing an Abstract Syntax Tree in C++
https://lesleylai.info/en/ast-in-cpp-part-1-variant/
https://redd.it/1caxnuq
@r_cpp
Survey participants needed on feature flag. 3-5min max :D
Hey friendos! I'm doing a research of usage of feature toggles AKA feature flags and I'm studying how Uber Cadence along with other project in other languages using feature flag in their project. We made a toggle detector tool:https://github.com/mzhfei/FeatureToggleDetector here. If anyone is interested in please feel free to give it a try! We also have a survey:https://forms.gle/EUB7A2iq7H2zzEr16, if anyone wants to give it a quick look would be fantastic! It will only take you about 3-5 minutes. And you don't have to download/run the tool to answer the questions either. Let me if you have any questions! Thanks in advance.
https://redd.it/1cawkhu
@r_cpp
Linux & ASIO, has anyone ever seen this? Stuck in Linux OS call ::send for >20 minutes.
Hey everyone!
We are currently experiencing something interesting. We are using ASIO as a simple TCP Server. It does not need to do much it keeps connections for around 10 seconds and has to send 100 messages per connection usually much smaller than 2kB.
This server is running on a low spec debian system, only in one thread. It usually runs fine but sometimes typically with higher load this happens:
the internal ASIO ::send calls to linux go suddenly from taking <1ms to one taking over 20 minutes!
I am a bit at a loss to how this is even possible - an os call taking so long seems absurd.
Has anyone experienced something similar before?
Does anyone know why this can happen?
Cheers!
https://redd.it/1cahtuw
@r_cpp
https://www.youtube.com/watch?v=0iiUCuRWz10
https://redd.it/1caecdi
@r_cpp
Xmake v2.9.1 released, Add native lua modules support
https://github.com/xmake-io/xmake/wiki/Xmake-v2.9.1-released,-Add-native-lua-modules-support
https://redd.it/1cabq92
@r_cpp