C++ - Reddit

constexpr Dynamic Memory Allocation, C++20 - variable size containers allowed! https://www.cppstories.com/2021/constexpr-new-cpp20/ https://redd.it/maj7xy @r_cpp

Using C++17 to Create Composable, Recursive Data Types https://davidgorski.ca/posts/recursive-data-types-cpp/ https://redd.it/maadka @r_cpp

Differences between the coding standards of Google, Gnu and Coreguidlines The title almost said it. Is there a page that lists the exact differences between the coding standards of Google, Gnu and Coreguidelines? I'm just trying to find an overview. Thanks in advance. I've already seen Nicolai Josuttis's video ​ Ben https://redd.it/ma6pw6 @r_cpp

Guideline for passing smart pointers sharedptr and uniqueptr in functions https://levelup.gitconnected.com/passing-smart-pointers-in-c-479775632443 Hi All, I have compiled few guideline diagrams article on how to pass shared_ptr and unique_ptr in function arguments for optimal performance and what to pass at the time of return. After reading Herb's blog, C++ guidelines, and a few other references I have put together this and few guideline matrices which are in this article. This article covers the following - 1. Always ask yourself “Do I really need to pass a smart pointer” 2. std::unique_ptr usage 3. std::shared_ptr usage 4. How to pass correctly pass raw pointer/reference. 5. For Returning smart pointers, what is the norm? I searched but never found a good graphical representation of these guidelines, hence I thought I'd give that a try :) Please help me in improving anything which is incorrect or missing in this. https://redd.it/ma1l5y @r_cpp

dxoygen awesome css : make your doxygen docs looking more modern I recently found that, what makes doxygen generated docs really looking awesome (imho): https://jothepro.github.io/doxygen-awesome-css/ https://redd.it/ma2r2r @r_cpp

Good content for learning c++ with no programmnig experience Hello! My sister is going to start a computer science education in a few months, which is C++ heavy. I thought it would be useful for her to start experimenting with C++ now since she has a lot of spare time at the moment. Do you have any REALLY basic tutorial for starting hello world c++, preferable a series of short videos? Perhaps a good one on udemy / youtube? :) https://redd.it/ma2sus @r_cpp

Reflecting Over Members of an Aggregate https://bitwizeshift.github.io/posts/2021/03/21/reflecting-over-members-of-an-aggregate/ https://redd.it/ma1n89 @r_cpp

Partial specialization of templates over non-type literal parameters in C++20: clang and gcc disagree https://stackoverflow.com/questions/66731338/partial-specialization-of-templates-over-non-type-literal-parameters-in-c20-c https://redd.it/m9wvnb @r_cpp

Releasing lazymap C++ library I developed a lazy\map library, whose interface is similar to std::unordered_map but lazy_map is O(1) copiable. Other operations like Deletion, Lookup, Insertion etc. continue to cost O(1)..  which also implies that lazy_map is not a simple cow_wrapper<std::unordered_map> .. lazy_map is way more clever than that. Learn more at : https://github.com/tinytrashbin/lazy\_map Specially, checkout the section which explains the "Fragment" tree. Lazy_map is heavily used in our codebase for taking snapshot of a very large  state ( of size \~ 5 GBs), enabling "fork" of a snapshot in O(1) time for further  modification in the forked snapshot, allowing a large number of threads to operate on different snapshots of very large size, concurrently without interfering with each other where each of the thread is even "writing" to their snapshot. I believe such a utility will be very helpful for others too. Take a look and let me know if it's helpful for you. https://redd.it/m9uwaq @r_cpp

Schema validation library for C++ 20 Hi C++ folks!! I love C++ so I time to time work on some apps and libraries in C++. I've been working on this one (for such long time) for fun and as a way to practice C++ concepts (eh I don't mean the #include <concepts> :d) I learn but then I got hooked on it and have gotten it to a state that I believe can be presented to others. I haven't run benchmarks against it but I have worked hard on keeping it fast and not as memory hungry as some of the other libraries I've worked with. I've got to run some benchmarks to see where it stands on the performance but I don't use virtual tables for the container wrappers for instance and made sure in a lot of cases the wrappers get optimized away. This is my first ever C++ library! well the first public one at least so I'm real excited to hear your thoughts on it. I would really appreciate constructive feedback. This is pretty alpha at the moment but the general idea is pretty clear in it. I know there are other similar libraries out there but I wanted to use concepts and make it easier to encode/decode without using macros, so it's kinda similar to encoding/decoding in Swift, at least in certain ways. Anyway, what I would love to determine over the next few days hearing feedback from people is whether or not this is something people would find useful or if I should just keep this to me for fun :) Repository: https://github.com/peymanmortazavi/garlic-models Documentation: https://peymanmortazavi.github.io/garlic-models/index.html &#x200B; If you want to actually compile and test this, you need GCC 10 so you can use C++ 20. I definitely need to work to make this work for other compilers and not require C++ 20 but I have not started on that part yet. https://redd.it/m8xp00 @r_cpp

djinni generator v0.3.1 released https://github.com/cross-language-cpp/djinni-generator/releases/tag/v0.3.1 (Djinni is a tool for generating cross-language type declarations and interface bindings. It's designed to connect C++ with either Java or Objective-C.) docs: https://djinni.xlcpp.dev https://redd.it/m9ejyn @r_cpp

Making Your Own Container Compatible With C++20 Ranges https://www.reedbeta.com/blog/ranges-compatible-containers/ https://redd.it/m9r1ww @r_cpp

TTauri 0.3: A boost licensed, C++20 retained GUI library. You can find the ttauri library at [https://github.com/ttauri-project/ttauri](https://github.com/ttauri-project/ttauri). A few weeks ago I released ttauri; which is a C++20 retained GUI library designed for performance, ease of use, modern looking, and with a low number of external dependencies. Since then we concentrated on making it easy for developers to work on the ttauri library, and more importantly for developers to include ttauri as a library for their own applications. One of the ease-of-use efforts went into the creation of an out-of-tree [ttauri\_hello\_world](https://github.com/ttauri-project/ttauri_hello_world) example application. This application is configured to import the ttauri library via **vcpkg**; and build the application into an zip file, ready to be code-signed and packaged into self extracting archive with the [ecpack-and-sign](https://github.com/ttauri-project/ecpack-and-sign) tool. Here are some of the important changes for this release: * TTauri can now be build using the non-preview version of Visual Studio. * Removed the embedded dependencies and instead making them installable via vcpkg. * Made a vcpkg 'ttauri-port' so that ttauri can be used as a dependency itself. * Created the ecpack-and-sign tool for hands-on code-signing and packaging of the application, the uninstaller and the installer. * We've made several API usability improvements, such as: * making the widget's coordinate system relative to the widget; * now using high level geometric types such as vector, point and color in as many places as possible; * replacing the hidden state in the draw context to explicit arguments in draw calls; and * changing the cell-coordinate system when placing widget on a grid layout to Excel-like cell-coordinates. https://redd.it/m96i08 @r_cpp

A smart open-source memory pool for C++ Hi guys, I love open-source so I decided to start a start-up with a friend and along the way to release all of our tools as open-source for everyone to use and enjoy. A great thing I achieved lately is to create a very fast and efficient memory pool in C++ which was developed with according to data-oriented design principles. It can help you make much faster memory allocations and reallocations. Here's the source code & readme: https://github.com/DevShiftTeam/CPPShift-MemoryPool I hope that it will help you with your project, and would love to get your help/suggestions and more to make it better for everyone :) I plan to release many more tools under the "CPPShift" namespace for C++ that are helpful for big and performance based software, so stay tuned and happy programming ;) https://redd.it/m9f5wo @r_cpp

The Best Machine Learning Courses on Udemy (According to Experts) https://www.pythonstacks.com/post/machine-learning-courses/ https://redd.it/m99oo4 @r_cpp

Clare Macrae - Quickly and Effectively Testing Qt Desktop Applications - Meeting C++ online https://www.youtube.com/watch?v=jwixAjDH2Ik https://redd.it/m94s7e @r_cpp

WTF is Pointer bugs? Why everybody hates it? [ Even James gosling hated this so much , that led him to made java.\] But I love c++, What alternative can i use except to using pointers in new c++? https://redd.it/m8xdzl @r_cpp

Top 5 Mistakes I Made When I Was a Newbie in Programming https://medium.com/techtofreedom/top-5-mistakes-i-made-when-i-was-a-newbie-in-programming-d8cef4112971 https://redd.it/m8ke58 @r_cpp

Guidelines for using raw pointers in modern C++ and GPUs Getting the obvious out of the way, yes, the conventional wisdom is "don't use raw pointers in modern C++". However, I've been playing with various GPU-acceleration frameworks (kokkos, raja, OneAPI, ...) where one needs to be meticulous about where memory lives -- a pointer to the start of a data array in the "host" memory is meaningless in the execution space of the "device" / GPU. By extension, STL containers generally don't work, and even simple C arrays need some kind of deliberate memory transfers and adjustments of the corresponding data pointers to execute correctly within these frameworks. e.g. in quasi-pseudocode, double * a = new double[n]; double * b = new double[n]; parallel_for(n, [=](auto i) { a[i] = b[i]; }) if that `parallel_for` is executing on CPU all is fine, but will fail on GPU. If you use `std::vector` here it will fail at runtime. Furthermore, to use my own functions in these frameworks I find myself needing them to be pure -- simple functions that take data pointers and array lengths, e.g. void copy_arrays(double * a, double * b, size_t len){ parallel_for(len, [=](auto i) { a[i] = b[i]; }); } which, if the data pointers and execution space are amicable, will work correctly. Writing code like this with raw pointer interfaces feels decidedly un-C++'y, but raw pointers also work transparently in all these various frameworks. I'm curious if anyone has suggestions for safely/correctly writing otherwise modern C++ with raw pointer code like this. Some obvious ones that come to mind: * Still never use `new`/`delete`, use some other memory management that can return raw pointers with `.data()`. * Prioritize pure functions -- they should have no side effects and no dependence on external data. All arguments should be PODs copied by value, or data pointers. Thoughts? https://redd.it/m8jegx @r_cpp

STL algorithms for programming interviews https://www.betamark.com/blog/stl-algorithms-for-programming-interviews/ https://redd.it/m8gmid @r_cpp