C++ - Reddit

Best practice for proxy objects for operator[]? So `vector<bool>` is a cautionary tail, yeah? But there's still situations where the only way to provide an `operator[]` that allows setting is to use a proxy object. For example, struct nibble_pair{ uint8_t e0: 4; uint8_t e1: 4; ... }; Can have a read-only `operator[]` just fine, but if you want setting too, I believe you need to return a proxy object. This does not play nice with `auto` in particular. What are some design concerns here? Do you know of any pitfalls? Examples where this has been used and worked well? I think the proxy object returned should include a copy of the data you might read, in case someone does auto look_it_up(){ return some_nibble_pair[0]; } int main(){ return look_it_up(); } nothing will dangle. https://redd.it/mzlptn @r_cpp

SIMD for C++ Developers [pdf] http://const.me/articles/simd/simd.pdf https://redd.it/mzqn0v @r_cpp

GCC 11.1 Released https://gcc.gnu.org/pipermail/gcc/2021-April/235922.html https://redd.it/mzpfyj @r_cpp

C++ Lambdas Under the Hood Previously I've written about how to use C++ lambdas. That post didn't bring much in the way of how lambdas actually work though. I wanted to write up how they actually work but, given that there are already a few great write ups out there, I wrote up a simple explanation and linked to those who've provided a much better (and more thorough) explanation: https://blog.taylorbuiltsolutions.com/how-do-c-lambdas-work/ https://redd.it/mzd0vj @r_cpp

Cross: Meson 0.58.0.rc1 is out. Please test it out and report any regressions discovered https://github.com/mesonbuild/meson/releases/tag/0.58.0.rc1 https://redd.it/mzkk2c @r_cpp

Location, Location, Location https://steveire.wordpress.com/2021/04/27/location-location-location/ https://redd.it/mzkb2a @r_cpp

Abuse co_await operator for error handling https://cpp-rendering.io/c-error-handling-lets-abuse-the-co_await-operator/ https://redd.it/mzjcs0 @r_cpp

MSVC's STL is C++20 feature complete for VS 2019 16.10 Preview 3 https://github.com/microsoft/STL/wiki/Changelog#expected-in-vs-2019-1610-preview-3 https://redd.it/mz8rkr @r_cpp

ML performance engineer explaining computer concepts in simple and short videos using C++ and some profilers. https://www.youtube.com/c/CoffeeBeforeArch/videos?view=0&sort=p&flow=grid https://redd.it/mz7bkg @r_cpp

C++ coroutines: What does it mean when I declare my coroutine as noexcept? https://devblogs.microsoft.com/oldnewthing/20210426-00/?p=105153 https://redd.it/mz3ex1 @r_cpp

Have you ever seen a do/while loop used? I've never used one. I've never come across one. I don't think I've ever had a need for one. It feels like the 7 key on the microwave. Are there any other basic language features that aren't used? https://redd.it/myvxrz @r_cpp

Static analysis tools for Misra C Hello, i am studding Electrical engineering and i will have to develop a project compliant with Misra C rules. I want to use a static analysis tool like Helix QAC or Polyspace Bug finder/Code Prover. The problem is that this are paid, and i cant seem to find information about how much time the trial version gives me. Does anybody know this? I could request the trial version for everyone of those, but i don't want to risk "burning" my time right now if it wont be enough to finish the project (i have about 1,5 month ). So i decided to ask here. Also is there any open source or free static analysis tool out there that is reliable and capable? I can't seem to find any open source project like that. https://redd.it/myv08b @r_cpp

Turn clang-tidy warnings and fixes to comments in your pull request If you are using clang-tidy for static analysis and hosting your C++ project on GitHub, then you can now use the platisd/clang-tidy-pr-comments GitHub Action to turn the clang-tidy warnings into code review comments and suggestions for your pull request. This can be useful if you do not want to go through terminal logs to find out why exactly your CI job is failing. Instead, you get the error along with a possible fix as a comment in the pull request. ⚠️ Note this GitHub Action will not run clang-tidy for you but merely utilizes the --exported-fixes YAML report and turns warnings and fixes into comments. https://redd.it/myvhtf @r_cpp

Parsing Protobuf at 2+GB/s: How I Learned To Love Tail Calls in C https://blog.reverberate.org/2021/04/21/musttail-efficient-interpreters.html https://redd.it/mywaoj @r_cpp

Foundations of C++ Type System C++ has a very powerful type system that allows to express a lot of concepts at compile time. In particular, with generics and constexpr, you can achieve some sort of dependent typing like the following: template<size_t A, size_t B> String<A+B> concat(String<A>, String<B>) //Where String<N> is a string of N chars I was wondering where can I find information about how these parts of the type system have been built (e.g. RFCs, design documents, committees). Moreover, I am also looking for (although I don't know if they exist) theoretical papers that correspond to the type system of C++. Finally, if by any chance somone knows other languages that offer these sort of integer generics I would also be interested (I only know "const generics" in Rust and is still under development). Thanks! https://redd.it/mytmue @r_cpp

Simplify Code with if constexpr and Concepts in C++17/C++20 https://www.cppstories.com/2018/03/ifconstexpr/ https://redd.it/mys67d @r_cpp

Optimizing the Docker Container Image for C++ Microservices https://www.perforce.com/blog/hdx/optimizing-docker-container-image-c-microservices https://redd.it/myszzk @r_cpp

All C++20 core language features with examples https://oleksandrkvl.github.io/2021/04/02/cpp-20-overview.html https://redd.it/myspms @r_cpp

Single header functional iterator library https://github.com/NasalDaemon/iter Having used iterator libraries in Rust, Scala and even Python, I miss the ability to write simple transformations of containers in C++. Yes, there is std::ranges, but it's missing basic things like accumulate, and zip, and is still quite verbose. Due to the fact that C++ iterators need so much boilerplate, it is also quite difficult and tedious to create your own range adaptors. To overcome these pitfalls, I created a new library, which abandons C++ iterators in favour of a new "iter" concept which just returns std::optional<T> if there is a next element. To become an iter, you just need to implement one method for your class. It also works nicely with range-based for loops. This technique optimises away amazingly well, and often produces better (and faster) assembly than C style loops and std::ranges (of course), and still gets auto-vectorised when possible. The code is released on GitHub in alpha. It's a single file header, only 2.5k lines of source code. It pretty much mirrors 95% of the rust iterator library in functionality, and I plan to add more. Example usage: [Godbolt](https://godbolt.org/#g:!((g:!((g:!((h:codeEditor,i:(fontScale:14,fontUsePx:'0',j:1,lang:c%2B%2B,selection:(endColumn:1,endLineNumber:29,positionColumn:1,positionLineNumber:29,selectionStartColumn:1,selectionStartLineNumber:29,startColumn:1,startLineNumber:29\),source:'%23include+%22https://tinyurl.com/libiter%22%0A%0A%23include+%3Carray%3E%0A%0A//+Auto-vectorized+/+zero-overhead%0A//+Interop+with+std::array%0A//+Interop+with+range-based+for+loop%0A%0Avoid+multiply(std::array%3Cfloat,+64%3E+const%26+x,+std::array%3Cfloat,+64%3E+const%26+y,+std::array%3Cfloat,+64%3E%26+z\)+%7B%0A++for+(auto+%5Ba,+b,+c%5D+:+iter::zip(x,+y,+z\)\)+%7B%0A++++c+%3D+a+*+b%3B%0A++%7D%0A%7D%0A%0A//+Pipe+syntax%0A//+Still+auto-vectorized%0A%0Afloat+weighted_sum(std::array%3Cfloat,+64%3E+const%26+a\)+%7B%0A++return+a%0A++++%7C+iter::enumerate(\)%0A++++%7C+iter::map+%7C+%5B%5D(auto+ai\)+%7B%0A++++++++auto%26+%5Ba,+i%5D+%3D+ai%3B%0A++++++++return+a+*+i%3B+%7D%0A++++%7C+iter::sum(\)%3B%0A%7D%0A%0Ausing+namespace+iter%3B%0Ausing+namespace+xtd::literals%3B%0A%0A//+Constexpr+friendly%0A%0Astatic+constexpr+int+sum_0_to_9+%3D+indices+%7C+take(_,+10\)+%7C+sum(\)%3B%0Astatic_assert(sum_0_to_9+%3D%3D+45\)%3B'\),l:'5',n:'0',o:'C%2B%2B+source+%231',t:'0'\)\),k:52.80187823291271,l:'4',n:'0',o:'',s:0,t:'0'\),(g:!((g:!((h:compiler,i:(compiler:g103,filters:(b:'0',binary:'1',commentOnly:'0',demangle:'0',directives:'0',execute:'1',intel:'0',libraryCode:'0',trim:'1'\),fontScale:14,fontUsePx:'0',j:1,lang:c%2B%2B,libs:!(\),options:'-std%3Dc%2B%2B20+-Ofast',selection:(endColumn:1,endLineNumber:1,positionColumn:1,positionLineNumber:1,selectionStartColumn:1,selectionStartLineNumber:1,startColumn:1,startLineNumber:1\),source:1\),l:'5',n:'0',o:'x86-64+gcc+10.3+(Editor+%231,+Compiler+%231\)+C%2B%2B',t:'0'\)\),k:47.19812176708729,l:'4',m:50,n:'0',o:'',s:0,t:'0'\),(g:!((h:output,i:(compiler:1,editor:1,fontScale:14,fontUsePx:'0',wrap:'1'\),l:'5',n:'0',o:'%231+with+x86-64+gcc+10.3',t:'0'\)\),header:(\),l:'4',m:50,n:'0',o:'',s:0,t:'0'\)\),k:47.19812176708729,l:'3',n:'0',o:'',t:'0'\)\),l:'2',n:'0',o:'',t:'0'\)\),version:4) float weighted_sum(std::vector<float> const& a) { return a | iter::enumerate() | iter::map | [](auto ai) { auto& [a, i] = ai; return a * i; } | iter::sum(); } https://redd.it/myl0yk @r_cpp

Copper: Powerful and convenient communication between threads https://github.com/atollk/copper Ever since I tried out Go, I was fascinated how easy and fun concurrency can be. This is thanks both to the "go" command / goroutines and to "channel" objects. "Copper" is my attempt (and, to my knowledge, the only open source attempt so far at all) to make the latter available in C++ with their entire feature set that exists in Go. For those unfamiliar: A Go channel is a synchronized queue-like object for message-based communication between goroutines (read "threads" in this context). Feedback and all other types of comments are appreciated. https://redd.it/myliey @r_cpp