-
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
Would C++26's introduction of reflection push vendors towards an ABI break?
As you know, one of the main gripes with C++ development is related to compilation time. Compiler vendors constantly strive to make improvements in this area, in spite of new STL features being constantly added. C++26 is going to be quite special in this regard though afaik, having the reflections proposal accepted. Reflections being probably the biggest metaprogramming extensions ever added to the language, even bigger than concepts and require clauses.
I'm saying this because I was watching this particular talk by Alexander Fokin describing it: https://youtu.be/FqzrQf6Xr8g?si=oe6L0askoOzQjSlC&t=3592 . What immediately caught my attention was the example of how you could implement std::tuple (almost fully) in what? 20 lines of code? For reference, MSVC's implementation is a header with more than 1000 lines of code ( https://github.com/microsoft/STL/blob/main/stl/inc/tuple ), containing dozens of helper class template instantiated for each instance of std::tuple used in real code. A fair assumption would be that the std::meta version would be far faster to compile, reflections being a very straight-forward way of expressing your intent to the compiler. In real life scenarios this could results in an immense amount of time saved at compilation time. And better yet, the opportunity of rewritting std::tuple would be a big bonus too since none of the standard implementations are optimal ( https://www.reddit.com/r/cpp/comments/ilujab/it\_turns\_out\_stdtuple\_is\_not\_a\_zerocost/ ).
Again, I'm not talking just about std::tuple here, I'm assuming there are dozens of STL components that could use being rewritten using reflections, if for nothing else, at least for the sake of compilation time. I'm wondering if this new feature couldn't be the push vendors have needed to take into consideration a real ABI break with one of their future releases, considering the compilation time improvements now available on the table.
https://redd.it/1cs5v48
@r_cpp
Going from embedded Linux to low latency distributed systems
Hi all,
My first job out of college has primarily involved writing code that runs in a real time Linux environment. The code I've written wasn't the kind that focused on being ultra optimized. Instead, the focus was moreso on readability and reliability. We usually are not allowed to use most modern C++ features. Our coding standard is often described as "C with classes."
I have an interview coming up for a low latency position that also involves distributed systems. What would this kind of C++ development entail compared to what I'm currently doing?
In other words:
- What are some high level concepts I might want to familiarize myself with before the interview?
- More broadly speaking -- if, against all odds, I manage to land the position, what new skills might I be learning? What might I need to study up on in my own time? What would my day to day development look like? How might this differ from the development of an embedded software engineer?
Thanks!
https://redd.it/1cs00mr
@r_cpp
Declarative GUI Slint v1.6 released with Design Mode (WYSIWYG) Improvements
https://slint.dev/blog/slint-1.6-released
https://redd.it/1crsfns
@r_cpp
exporting wms
I've recently been into Windows Media Player skins from the 2000s and i found an archived tutorial on how to make my own, combining C++ and Photoshop skills. At some point though, the tutorial orders exporting the code in wms file. I was using notepad and copying the same tactics and wording as the tutorial, with all the WMP SDK lingo, but the notepad only had export choices for ".txt" and "All Files". I dont know much about coding so please help me (i tried to send a screenshot of the website but I dont think i can add an image here)
https://redd.it/1crnxod
@r_cpp
Any C++ refresher suggestions?
I was coding in C++ a few years ago and switched to python then. I am wondering if there are any books/websites/courses for refresher like me to study and deep dive into it.
https://redd.it/1crnl3f
@r_cpp
prefix vs postfix incrementation
I understand the difference between (++i and i++), but which is preferred. When learning cs50x and after that in C, I've always done postfix incrementaiton. Rcecetnly starting learning cpp from learncpp.com, and they strongly recommened us to use prefix incrementation which looks a bit weird. Should i make the change or just keep using postfix incrementation since Im more accustomed to it
https://redd.it/1crk95m
@r_cpp
JSON library to deserialize in memory
Hi there,
I'm wondering whether there's JSON libraries can deserialize and point to input buffer(s) when deserializing?
Use case: I'm building a system where I get input data by communication channels, pass it to a deserializer function that writes data out to std::string_view.
When the callee function use JSON library which copies from the buffer, the std::string_view points to local memory that will be invalidated when it returns the parsed data.
I hope I made it clear enough, if not, please inquire.
Regards,
Hamza
https://redd.it/1cr90nx
@r_cpp
New C++ Conference Videos Released This Month - May 2024 (Updated To Include Videos Released 05/06/2024 - 05/12/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
C++Online
05/06/2024 - 05/12/2024
Advanced SIMD C++ Algorithms in Pictures - Denis Yaroshevskiy - [https://youtu.be/uAVXVzWIIBM](https://youtu.be/uAVXVzWIIBM)
Optimising a High Performance C++ Library: Lessons Learned - Dave Rowland - https://youtu.be/c\_cXuL\_L0Gg
Keynote: What Does It Take to Implement the C++ Standard Library? - Christopher Di Bella - [https://youtu.be/XP21DsoPaGw](https://youtu.be/XP21DsoPaGw)
04/29/2024 - 05/05/2024
What’s New in Compiler Explorer? 2024 Update - Matt Godbolt - https://youtu.be/28Gp3TTQYp0
Clean C++ Code Is Not the Norm: Why? - Sandor Dargo - [https://youtu.be/Rn6EMwPoHZk](https://youtu.be/Rn6EMwPoHZk)
Pure Virtual C++
05/06/2024 - 05/12/2024
Automated Testing of Shader Code - Keith Stockdale - https://www.youtube.com/watch?v=eqnNOhOCesc
Progress Report: Adopting Header Units in Microsoft Word - Zachary Henkel - [https://www.youtube.com/watch?v=RvliLGtaQ0c](https://www.youtube.com/watch?v=RvliLGtaQ0c)
Templates View for Build Insights in Visual Studio - Nelson D. Troncoso - https://www.youtube.com/watch?v=68pOEQ5YA5s
04/29/2024 - 05/05/2024
Optimizing Game Development Workflows with Visual Studio and AI - David Li & Greg Denton - [https://www.youtube.com/watch?v=mZ4uS8\_lUzM](https://www.youtube.com/watch?v=mZ4uS8_lUzM)
Debugging GUI Applications in a GitHub Codespace - Michael Price - https://www.youtube.com/watch?v=ewLbgs1thSk
New Editor Features in Visual Studio for C++ Programmers - Haley Welliver and Caleb Blake - [https://www.youtube.com/watch?v=DgfSJ2\_2TGI](https://www.youtube.com/watch?v=DgfSJ2_2TGI)
Message Handling with Boolean Implication - Ben Deane - https://www.youtube.com/watch?v=aIPvb\_PaI1A
Enhancing C++ development with Copilot Chat - Sinem Akinci - [https://www.youtube.com/watch?v=GpxPB6FuIAM](https://www.youtube.com/watch?v=GpxPB6FuIAM)
I Embedded a Programming Language In Debug Information - Sy Brand - https://www.youtube.com/watch?v=luogje8IHpM
CppCon
05/06/2024 - 05/12/2024
Lightning Talk: Is Polymorphism in C++ Really That Bad? - Paul Tsouchlos - [https://youtu.be/BujbOFNHHIY](https://youtu.be/BujbOFNHHIY)
Lightning Talk: Program Complexity and Thermodynamics - Vadim Alexandrov - https://youtu.be/E1\_AgDj\_2kw
Lightning Talk: Undefined Behavior - Toolkit to Improve Communication With Clients - Laura Kostur - [https://youtu.be/zKZiWVNenVk](https://youtu.be/zKZiWVNenVk)
Lightning Talk: Detecting Constant Folding to Prevent Substitution Failure - Patrick Roberts - https://youtu.be/Hoo9H9z-0VM
Lightning Talk: Making Friends With CUDA Programmers (please constexpr all the things) - Vasu Agrawal - [https://youtu.be/TRQWxkRdPUI](https://youtu.be/TRQWxkRdPUI)
04/29/2024 - 05/05/2024
Lightning Talk: Let's Fix Sparse Linear Algebra with C++. It'll Be Fun and Easy! - Benjamin Brock - https://youtu.be/vhpj-pQTJPA
Lightning Talk: (Fine) Wine and MSVC: What Could Possibly Go Wrong? - Yannic Staudt - [https://youtu.be/ogrJtlaZfl4](https://youtu.be/ogrJtlaZfl4)
Lightning Talk: Know Your Audience: Who’s Building Your C++ Code - Chris Thrasher - https://youtu.be/xSrEHZ6Sgfg
Lightning Talk: Writing a Better std::move - Jonathan Müller - [https://youtu.be/hvnl6T2MnUk](https://youtu.be/hvnl6T2MnUk)
Lightning Talk: Enhancing C++ exceptions with Context - Shachar Shemesh - https://youtu.be/LvzmAJ9\_rDk
All of
New C++ Conference Videos Released This Month - May 2024 (Updated To Include Videos Released 05/06/2024 - 05/12/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
C++Online
05/06/2024 - 05/12/2024
Advanced SIMD C++ Algorithms in Pictures - Denis Yaroshevskiy - [https://youtu.be/uAVXVzWIIBM](https://youtu.be/uAVXVzWIIBM)
Optimising a High Performance C++ Library: Lessons Learned - Dave Rowland - https://youtu.be/c\_cXuL\_L0Gg
Keynote: What Does It Take to Implement the C++ Standard Library? - Christopher Di Bella - [https://youtu.be/XP21DsoPaGw](https://youtu.be/XP21DsoPaGw)
04/29/2024 - 05/05/2024
What’s New in Compiler Explorer? 2024 Update - Matt Godbolt - https://youtu.be/28Gp3TTQYp0
Clean C++ Code Is Not the Norm: Why? - Sandor Dargo - [https://youtu.be/Rn6EMwPoHZk](https://youtu.be/Rn6EMwPoHZk)
Pure Virtual C++
05/06/2024 - 05/12/2024
Automated Testing of Shader Code - Keith Stockdale - https://www.youtube.com/watch?v=eqnNOhOCesc
Progress Report: Adopting Header Units in Microsoft Word - Zachary Henkel - [https://www.youtube.com/watch?v=RvliLGtaQ0c](https://www.youtube.com/watch?v=RvliLGtaQ0c)
Templates View for Build Insights in Visual Studio - Nelson D. Troncoso - https://www.youtube.com/watch?v=68pOEQ5YA5s
04/29/2024 - 05/05/2024
Optimizing Game Development Workflows with Visual Studio and AI - David Li & Greg Denton - [https://www.youtube.com/watch?v=mZ4uS8\_lUzM](https://www.youtube.com/watch?v=mZ4uS8_lUzM)
Debugging GUI Applications in a GitHub Codespace - Michael Price - https://www.youtube.com/watch?v=ewLbgs1thSk
New Editor Features in Visual Studio for C++ Programmers - Haley Welliver and Caleb Blake - [https://www.youtube.com/watch?v=DgfSJ2\_2TGI](https://www.youtube.com/watch?v=DgfSJ2_2TGI)
Message Handling with Boolean Implication - Ben Deane - https://www.youtube.com/watch?v=aIPvb\_PaI1A
Enhancing C++ development with Copilot Chat - Sinem Akinci - [https://www.youtube.com/watch?v=GpxPB6FuIAM](https://www.youtube.com/watch?v=GpxPB6FuIAM)
I Embedded a Programming Language In Debug Information - Sy Brand - https://www.youtube.com/watch?v=luogje8IHpM
CppCon
05/06/2024 - 05/12/2024
Lightning Talk: Is Polymorphism in C++ Really That Bad? - Paul Tsouchlos - [https://youtu.be/BujbOFNHHIY](https://youtu.be/BujbOFNHHIY)
Lightning Talk: Program Complexity and Thermodynamics - Vadim Alexandrov - https://youtu.be/E1\_AgDj\_2kw
Lightning Talk: Undefined Behavior - Toolkit to Improve Communication With Clients - Laura Kostur - [https://youtu.be/zKZiWVNenVk](https://youtu.be/zKZiWVNenVk)
Lightning Talk: Detecting Constant Folding to Prevent Substitution Failure - Patrick Roberts - https://youtu.be/Hoo9H9z-0VM
Lightning Talk: Making Friends With CUDA Programmers (please constexpr all the things) - Vasu Agrawal - [https://youtu.be/TRQWxkRdPUI](https://youtu.be/TRQWxkRdPUI)
04/29/2024 - 05/05/2024
Lightning Talk: Let's Fix Sparse Linear Algebra with C++. It'll Be Fun and Easy! - Benjamin Brock - https://youtu.be/vhpj-pQTJPA
Lightning Talk: (Fine) Wine and MSVC: What Could Possibly Go Wrong? - Yannic Staudt - [https://youtu.be/ogrJtlaZfl4](https://youtu.be/ogrJtlaZfl4)
Lightning Talk: Know Your Audience: Who’s Building Your C++ Code - Chris Thrasher - https://youtu.be/xSrEHZ6Sgfg
Lightning Talk: Writing a Better std::move - Jonathan Müller - [https://youtu.be/hvnl6T2MnUk](https://youtu.be/hvnl6T2MnUk)
Lightning Talk: Enhancing C++ exceptions with Context - Shachar Shemesh - https://youtu.be/LvzmAJ9\_rDk
All of
Addressing That Post About `final`
https://16bpp.net/blog/post/addressing-that-post-about-final/
https://redd.it/1cqz3n4
@r_cpp
I need to make practice in cpp
Is there any website to practice what I learn so far or what should I do to learn it more?
https://redd.it/1cqwqp5
@r_cpp
Proper location of <module-name>.cppm
I know it's question post and should be `r/cpp_questions`(https://www.reddit.com/r/cpp_questions/), but this is not a question with a fixed answer therefore I'm writing in here. Please tell me it is restricted.
---
I'm currently working for porting existing libraries like [magic_enum](https://github.com/Neargye/magic_enum/commit/7afc57b194dd08631d5e96e42b217bb52933828f), [fastgltf](https://github.com/spnda/fastgltf/pull/61#issuecomment-2106896979) and etc (which are used in my private module based projects). Changing dependencies with module is quite easy and giving me much benefits for compile time.
During porting, I'm curious about which folder is the proper location for module port file (which ends with `.cppm` or `.ixx` extensions). At first I think `src` or `module` is the answer, because it is not header file and cannot be included. However, I realized that package managers like vcpkg does not install files in those folders, but compile the sources files to static/shared libraries (which ends with `.a` or `.so` extensions).
Some module supporting libraries like [Vulkan-Hpp](https://github.com/KhronosGroup/Vulkan-Hpp/blob/main/README.md) and [glm](https://github.com/g-truc/glm/blob/master/glm/glm.cppm) locates the module file in include directory. In this case, vcpkg install the header files to `include` directory and user can fetch them using `${glm_SOURCE_DIR}/include/glm/glm.cppm` to declare module target.
There are many package managing strategies that are preserving file structures, but I think CMake + vcpkg is the de facto system for C++ developers, so I'm confusing about the proper module exposing method. I want to get your opinions.
https://redd.it/1cqu9u9
@r_cpp
GCC has now almost fully implemented C++23
I find it crazy how GCC (v14) has almost fully implemented the core language features of C++23 (except two features).
The standard was finalized in Feb 2023. GCC has managed to do this in little over a year after the standard came out. This is brilliant and rarely happens with modern compilers.
Thank you a ton to all the people who contributed to GCC and made all this possible.
https://redd.it/1cqs5ag
@r_cpp
Segfault in standard library (?)
I am encountering really weird behaviour in some code. When using boost::format, the function narrow from c++/11/bits/locale_facets.h on AlmaLinux9 is causing a segfault on the line where __t is assigned.char narrow(char_type __c, char __dfault) const {
if (_M_narrow[static_cast<unsigned char>(__c)])
return _M_narrow[static_cast<unsigned char>(__c)];
const char __t = do_narrow(__c, __dfault);
if (__t != __dfault)
_M_narrow[static_cast<unsigned char>(__c)] = __t;
return __t; }
I honestly have no idea what is causing this. Compiled with -O3, when compiled with no optimization flag I haven't encountered this issue.
https://redd.it/1cqo7eh
@r_cpp
What is the current status (production ready) of hot-reload? And if you had infinite resource how would you add it transparently to any code-base, say using CMake?
https://redd.it/1cqksdc
@r_cpp
If the standard library died (due to ABI concerns), is there a "stdlib killer"?
So, if 2020 marked the day the standard library died (allegedly), then what do I use instead?
In other words and in a more serious tone: is there a "best" general-purpose C++ primitives library that could theoretically become "the new stdlib", if we could magically disregard all existing code?
Or in yet other words: is there a library, or a set of libraries, that I should seriously consider using instead of stdlib and STL (on performance, ergonomics and usability grounds) in new projects where backward compatibility and simplicity of deployment is not a concern?
https://redd.it/1cs3n4f
@r_cpp
C++ DevContainer
Just created a simple up to date .devcontainer to try out modules with c++23. All gcc, clang and msvc build fine and seem to work, only major problem is still intellisense. Check it out and try if for yourself, feel free to leave a star:
https://github.com/vitaliy-ostapchuk93/cpp-dev-sandbox
https://redd.it/1crz3x4
@r_cpp
Would CPP be well suited for a application that searches and connects to bluetooth devices.
I am wanting to create an application that runs on my laptop that can connect a bluetooth HR monitor and other sensors to make a little game. Im having issues finding much information on how to do this and that made me wonder is cpp really the best choice for an application like this.
im a novice but cpp is what I am more familiar with.
https://redd.it/1crr2nk
@r_cpp
Practice CPP by topic/concept
Hello there. I’ve taken my sweet time before posting this because confusion has got the better of me. I have been working as a software engineer in the automotive industry for about 4 years now and I think I’m still not past my imposter syndrome phase. That is mainly because I feel I’m not growing and enhancing my skillset. With years of experience that I have bagged all these years, there’s certain expectations from future potential employers and from myself that I don’t think I can meet. So I came up with following plan to become a top-tier engineer:
1. Master programming language (C++)
2. Master Data Structures and Algorithms
3. Dive deep in embedded systems and relevant tools.
I had a discussion with one of my senior colleagues and he said “A lot of skill comes from doing it” which I agree with 100% but I get anxious when deciding between what I know and what I have to learn. I think I have covered the C++98 part including the OOP concepts. It’s the C++11 features that I think I really suck at.
I guess what I’m looking for is a feedback whether my plan has the right approach. If so, what platforms are out there other than leetcode that can help me practice C++ by topics/concepts so that I have certain confidence that I have covered topics well.
Any other guidance towards my ultimate goal is appreciated. Thanks.
https://redd.it/1cro0mu
@r_cpp
Thread Count Scaling
https://easyperf.net/blog/2024/05/10/Thread-Count-Scaling-Part1
https://redd.it/1crksru
@r_cpp
When to do a gather operation
I do a lot of numerical programming and I often wonder if it would be faster to do a copy to gather my data into contiguous memory before running an operation.
Is this something other programmers are asking themselves? I'd like to hear other people's thoughts on this as unit strides in memory or fastest but you're going to pay a hit for doing a copy to gather the data into contiguous memory.
https://redd.it/1crej78
@r_cpp
these talks can also be accessed at 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
05/06/2024 - 05/12/2024
Accelerated Audio Computing: From Problem to Solution - Alexander Talashov & Alexander Prokopchuk - [https://youtu.be/X9TN9la0Q0Y](https://youtu.be/X9TN9la0Q0Y)
Virtual Studio Production Tools With AI Driven Personalized Spatial Audio for Immersive Mixing - Dr. Kaushik Sunder & Krishnan Subramanian - https://youtu.be/Uhf4XUQwcLk
Workshop: An Introduction to Inclusive Design of Audio Products - Accessibility Panel - [https://youtu.be/-iVDiV1Iwio](https://youtu.be/-iVDiV1Iwio)
04/29/2024 - 05/05/2024
Legacy Code for the Learning Audio Engineer: Examples In C++ - José Díaz Rohena - https://youtu.be/b9z8a2z4ZP4
AI Generated Voices: Towards Emotive Speech Synthesis - Vibhor Saran - [https://youtu.be/5FoI9JPNbo8](https://youtu.be/5FoI9JPNbo8)
Audio Technology Industry Standards - the Agony and the Ecstasy - Angus Hewlett - https://youtu.be/wVxS9Rv1y88
https://redd.it/1cr2t2v
@r_cpp
I’ve maintaining this playlist for over five years. I use it when coding to keep me focused.
https://open.spotify.com/playlist/5cYftgvXTUikczMq6HqQCQ
https://redd.it/1cr4ieo
@r_cpp
what are the advantages and disadvantages of clang++ and g++
Hey guys, I've been coding cpp for a while now on linux. I use the default g++ that comes along with build-essential in ubuntu. I also heard that there is another popular compiler called clang++ for cpp files. I'm having troubles deciding whether I should make the swap? When using linux, we have an option to either install clang++ or g++. what would u install and why
https://redd.it/1cqyhed
@r_cpp
signal handling in thread pool on Linux
I'm writing a thread pool in c++ on Linux. So far it works but I want to make performance as good as possible.
The pool uses ZeroMQ, which recommends using sockets to connect threads to avoid locking primitives. So I have a proxy() function running in a separate thread. The proxy() function relays messages between a pair of sockets, frontend and backend. All worker threads connect to the backend socket.The proxy() relays messages between frontend and backend, as well as process heartbeats of the worker threads. ZeroMQ has a name for this pattern, PPP (Paranoid Pirate Pattern). Since ZeroMQ has a function zmq_poll(), which can poll the sockets, I have the zmq_poll() in both proxy() and worker process, going in a loop.This seems to be a very efficient way to build a message loop.
Because the pool has to be shutdown sooner or later, there must be a way to break these loops. I m currently using an std::atomic variable shared by both the proxy() thread as well as all the worker threads. When the pool is to be shutdown, I set this variable and join all threads. All good.
But then on Linux/UNIX we have signals. To me, it's both a bliss and a curse. The good part is it's a standard way of inter thread communication and it's already there. Bad part is it's asynchronous. It can happen anywhere, including inside system calls and user functions Then I found signalfd, which seems to fix most of the messes. It turns asynchronous signals into synchronous file descriptors. So I figured I can share 1 fd amongst the proxy thread and all workers. The proxy thread will create this fd and share it with the workers. Once the proxy thread poll() finds input available, it will read from this fd and if the signal is as expected, it will send signals to each of the workers using pthread_kill(). The workers will poll() on this fd but won't try to read(). As soon as poll() finds input available, worker will exit. As I found that there is no guarantee each thread will get its share of the signal. It is said the signals to the fd are not only buffered, but could also be merged. So far this arrangement seems to work. But I have serious doubt on whether this is the right way.
Firstly this all feels a bit too much just to handle Ctrl-C. Secondly, I'm not sure if this is an improvement over std::atomic. The atomic type is said to be a little expensive on CPU but better than the locks.But polling on fd, isn't it more expensive than std::atomic, even the locks?
https://redd.it/1cqx568
@r_cpp
Adding GUI to CLI app
https://github.com/webmessia-h/tcpClientServer
https://redd.it/1cqufiz
@r_cpp
C++ Multithreaded Count Benchmark
https://www.codeproject.com//Articles/5382229/Cplusplus-Multithreaded-Count-Benchmark
https://redd.it/1cqsneb
@r_cpp
C++ Unions: Accessing non-active array element which is guaranteed to not share space
Hello,
Consider the following C++ union:
```
struct Mystruct
{
char *p; // sizeof(p) == 8, alignof(p) == 8
uint32_t sz; // sizeof(sz) == 4, alignof(sz) == 4
}; // sizeof(MyStruct) == 16 (with padding),
// alignof(MyStruct) == 8
union U
{
MyStruct s;
char buf[16];
};
```
My question is can I safely read the **last** element only of buf[] even when buf[] is not the last written to (active) member of the union? I believe that based on the way unions must work in any compiler implementation this element (buf[15]) can never be overwritten by any write to the MyStruct s. Is that correct?
The primary objective is to be **as space-efficient as possible** while also working reliably.
What I'm doing: This union is the sole data member for a string class (we'll call it MyString). Within that string class the MyStruct struct (actually called AllocInfo) when used contains a pointer to and length of a dynamically allocated block of memory for the string (char* and uint32_t, respectively) when a string larger than 15 characters is stored. buf[] is used for short string optimization (SSO): the string is directly stored in this buffer if it will fit (15 or fewer characters). The last element of this char array is used as a flag. When SSO is used it is set to 0 and also doubles as the terminating null character of the string when the length of the stored string is exactly 15. When dynamically allocated memory is used this flag is set to 1. When I need to read the string I always read this flag first to determine how to access it.
Constraints: I am targeting C++11. Currently I am compiling on AMD64 Linux but I'm attempting to be as platform-agnostic as possible with an eye on compiling for ARM64 Linux at some point soon (the actual size of the buf[] char array is calculated at compile time to be guaranteed to always be at least one byte larger than the struct and also to align to alignof(max_align_t) for the platform). I am linking with **no libraries at all**. This means I can't use anything in the Standard C or Standard C++ Libraries nor anything in the std:: namespace.
- My understanding is that because I sometimes read the flag in buf[15] when the last member of the union written to was the MyStruct struct that is by definition Undefined Behavior (for C++11). I get that. However I also believe that the behavior in this particular case must be deterministic and do what I want because of the requirements for unions (union members share space and starting address). Am I correct in that assumption?
- In cases like this where individually accessed elements of an array in a union do not themselves share space with any other member of the union (because the starting address of the element is past the last address used used by any other union member) should that really be UB in C++?
- As far as I am able to ascertain the code **does** work perfectly with no issues on both GCC and Clang. Compiling with every warning flag and strictness level I can think of turned on, at the highest optimization level outputs no diagnostics and the code runs as expected. However compilers aren't required to emit a diagnostic for UB so I can't infer anything from that, correct?
- I could, of course, pull the flag out of the union and put it elsewhere in the string class. But doing that would mean that I can no longer use 100% of the size of the string instance for SSO which would make it a little slower and a little less space efficient in some cases which makes me sad. It could also mean increasing the sizeof(MyString) (currently 16) or making the string class itself not as space efficient in memory when many instances are dynamically allocated.
Is there a non-UB way to do what I'm doing while still allowing class instances to be just as space efficient?
Since everything seems to work as is should I just stop overthinking it?
https://redd.it/1cqpnl8
@r_cpp
Autogenerate C++ Boiler Plate Code
Hi Everyone,
I've written a tool at the company I work at that basically allow you to autogenerate any boiler plate code based off a yaml file and a Jinja template schema. At work, we use to tool to autogenerate C++ classes that have built in serialize/deserialize functionality for all kinds of different message classes that we work with. I've also written templates that can autogenerate Protobuf converters that convert a C++ message object to its protobuf equivalent. This has been super handy for us because we work with many different C++ message classes and hand typing all the converters would be tedious and error prone.
My question is: I am debating making this tool open source, but want to see if other people who write C++ encounter similar problems to this and if a tool like this would be valuable and helpful before I spent a bunch of time re-working it and making it available on GitHub.
Thanks!
https://redd.it/1cqljau
@r_cpp
WinDbg Time Travelling Debugger is Amazing Magic
https://www.forrestthewoods.com/blog/windbg-time-travelling-debugger-is-amazing-magic/
https://redd.it/1cqk5ne
@r_cpp