Milan Vukov

Dear C++ community, today I would like to talk about one, maybe not so familiar – for sure, not so widely used feature of std library. ☛ 𝗣𝗿𝗼𝗯𝗹𝗲𝗺: manufacturing the std::shared_ptr<T> from the reference on the enclosing class T will cause creating a new control block to manage the lifetime of the same underlying pointer – raw pointer “this”, which inevitable leads to the UB. ✔ 𝗦𝗼𝗹𝘂𝘁𝗶𝗼𝗻: one of the solutions offered by the std library itself is a practical implementation of CRTP idiom: 𝘀𝘁𝗱::𝗲𝗻𝗮𝗯𝗹𝗲_𝘀𝗵𝗮𝗿𝗲𝗱_𝗳𝗿𝗼𝗺_𝘁𝗵𝗶𝘀<𝗧>, so that any class T that implements the interface of this - “base” class, can safely produce the 𝘴𝘵𝘥::𝘴𝘩𝘢𝘳𝘦𝘥_𝘱𝘵𝘳<𝘛>from the non-static member function, by calling 𝘀𝘁𝗱::𝘀𝗵𝗮𝗿𝗲𝗱_𝗳𝗿𝗼𝗺_𝘁𝗵𝗶𝘀. Requirement is – that this method needs to be invoked on the existing instance of the std::shared_ptr<T>, from which the control block will be actually shared. For this to work as expected, we need to additionally ensure – through the design of the class T, that the constructor is private, and that there is a designated static factory method – as gateway that will create the initial std::shared_ptr<T>. @note: We can use the same technic with std::weak_from_this, to create the matching std::weak_ptr<T>. # Code example (Observer pattern) https://lnkd.in/dE26CAqN # Article https://lnkd.in/eCnt2E9B Feedback, as usual, more than welcome. #cpp #observerpattern #softwaredesign

60

26 Comments

Q:1 Can you store different size objects in a C++ vector directly? ************************** The simple answer is, No ************************** But in real life, we do see vectors keeping track of variable-size objects. Let's try to understand what can be different ways to handle this: 1. Just create the vector of pointers or references, and store the real object somewhere else in the memory. Now just save the reference/pointer of this object in the vector. ************************************** std::vector<ParentClass*> objects; objects.push_back(new ChildClass1); objects.push_back(new ChildClass2); ************************************** 2. Just use the union that can hold different types of data in the same memory location. This can be used to create a vector-like structure to store objects of different sizes. But we need to be extra cautious(in terms of type shaftey and memory management) when using this approach. 3. Just use dynamic memory allocation that in turn can be used to store objects of different sizes. example: ******************************************************** std::vector<std::unique_ptr<ParentClass>> objects; objects.push_back(std::make_unique<ChildClass_1>()); objects.push_back(std::make_unique<ChildClass_2>()); ******************************************************** A more advanced approach can be is, simply go and create a more efficient data structure that can efficiently manage different-sized objects. In any of the approaches always be careful of, Memory Leaks, Performance, etc I create content around advanced topics in C++ which are kind of very necessary to understand computer science fundamentals. Don't forget to visit, the link in the comment.

20

2 Comments

Q:1 Can you store different size objects in a C++ vector directly? ************************** The simple answer is, No ************************** But in real life, we do see vectors keeping track of variable-size objects. Let's try to understand what can be different ways to handle this: 1. Just create the vector of pointers or references, and store the real object somewhere else in the memory. Now just save the reference/pointer of this object in the vector. ************************************** std::vector<ParentClass*> objects; objects.push_back(new ChildClass1); objects.push_back(new ChildClass2); ************************************** 2. Just use the union that can hold different types of data in the same memory location. This can be used to create a vector-like structure to store objects of different sizes. But we need to be extra cautious(in terms of type shaftey and memory management) when using this approach. 3. Just use dynamic memory allocation that in turn can be used to store objects of different sizes. example: ******************************************************** std::vector<std::unique_ptr<ParentClass>> objects; objects.push_back(std::make_unique<ChildClass_1>()); objects.push_back(std::make_unique<ChildClass_2>()); ******************************************************** A more advanced approach can be is, simply go and create a more efficient data structure that can efficiently manage different-sized objects. In any of the approaches always be careful of, Memory Leaks, Performance, etc I create content around advanced topics in C++ which are kind of very necessary to understand computer science fundamentals. Don't forget to visit, the link in the comment.

28

2 Comments

In this tutorial, we'll dive into decision-making (selection) control statements in C++ and explore their various types with example programs. From if, if-else, nested if, to switch statements, you'll learn how to use these control structures effectively to make decisions in your C++ programs. Whether you're a beginner or looking to sharpen your skills, this video has you covered. Here, we have covered the following programs: 1. Program to check if an integer is positive or negative using if-else statement. 2. Program to print the day of the week using switch-case statement. https://lnkd.in/g8DSTt55 Like, share, Subscribe. #coding #beginners #programming #btech #diploma #BCA

2

Here is a link to an article of mine published by the ACM in September. https://lnkd.in/e38VMruG If you want to read it an don’t have access, you can find the preprint on Arxiv. https://lnkd.in/ekwtSEQy If you’d rather not read it, here is a podcast of it. It’s close enough to get the jist of it. Looses a lot of the detail and is somewhat repetitive. https://lnkd.in/ee8KEeEV

29

9 Comments

Hey, recall how the famous LDD3 book's 'Hello, world' introductory kernel module says 'goodbye'? (Ok, I'll tell you: "Goodbye, cruel world\n"). My recent - and very much updated, for 6.1 LTS - Linux Kernel Programming book (LKP 2E, the second edition), of course has an intro 'Hello, world' kernel module as well. But how does it say 'goodbye'? The first five people to correctly answer this win a free e-copy of the LKP 2E book! https://packt.link/xOfRu

58

17 Comments

💎 "𝐅𝐥𝐨𝐰 𝐄𝐧𝐠𝐢𝐧𝐞𝐞𝐫𝐢𝐧𝐠" 𝐢𝐬 𝐚 𝐭𝐞𝐫𝐦 𝐭𝐡𝐚𝐭 𝐡𝐚𝐬 𝐛𝐞𝐞𝐧 𝐠𝐚𝐢𝐧𝐢𝐧𝐠 𝐢𝐧 𝐩𝐨𝐩𝐮𝐥𝐚𝐫𝐢𝐭𝐲 𝐫𝐞𝐜𝐞𝐧𝐭𝐥𝐲 🟢 The first time it was mentioned as term was in CodiumAI paper on AlphaCodium, where they used flow engineering to produce state-of-the-art results on coding problems. 🟢 𝐅𝐥𝐨𝐰 𝐄𝐧𝐠𝐢𝐧𝐞𝐞𝐫𝐢𝐧𝐠 can be used for many problems involving reasoning, and can outperform naive prompt engineering. 💡 Instead of using a single prompt to solve problems, Flow Engineering uses an iterative process that repeatedly runs and refines the generated result. Better results can be obtained moving from a prompt : answer paradigm to a "flow" paradigm, where the answer is constructed iteratively. 🟢 #FlowEngineering is also an incredibly apt name to describe the types of problems that the #LangGraph framework seeks to solve. LangGraph is a low level, highly controllable framework for creating agentic and multi-agent applications. ️𝒌𝒊𝒏𝒅𝒍𝒚 𝒓𝒆𝒑𝒐𝒔𝒕♻️ LangChain #promptengineering #ai #llms #aiagents

14

1 Comment

Dear C++ community, CppCon, The C++ Conference has established a nice practice – to cover the modern C++ features as part of the Back to Basic Track sessions. It was inspirational for me – to write my own Back to Basic series. There is a new article about #Arrays – if not the most important data structure. Some highlights ● C-style array: how it decays to pointer ● Array type: definition, how to deduce array type ● C++ respond in form of std::array – compile time static array ● Multidimensional arrays: utilized on special locality and avoid cache misses # Link to the article https://lnkd.in/eeQEMF9B Feedback as usual more than welcome. #cpp #cplusplus #arrays #softwaredevelopment

95

The Clean C++ Strong-Typedefs That Never Were ================================ It would have been very useful to have different types that behave like (eg) `int`: it could both benefit optimizations (lookup 'strict aliasing') AND help write more robust code. For example, rewriting the function signature - `int calcPrice(int numApples, int applePrice);` into- `int calcPrice(AppleCount numApples, ApplePrice price);` would let the compiler stop you from mixing arguments. These are called strong-typedefs. Several attempts have been made to add syntax for them to the core language, and none passed the committee. Several libraries exist that come close by wrapping `int` in a struct with most `int` functionality and attributes. But in an imaginary world with different C++, there could have been a different, much cleaner, solution: Inherit `int`. That would have given a *new* type that inherited all of `int`s functionality, for practically free. So why can't we? Can you take a guess?

40

17 Comments

We performed a mesh convergence study for the contraction test problem using a PTT law for We=100!!! Look at the size of the vortice: it is HUGE 🤩. #viscoelasticity #CFD #FEM #PTT #mesh #convergence #vortice

27

4 Comments

Control synthesis with spatio-temporal specifications. A neuro-symbolic computation graph encodes an STL formula. This addresses issues with convexity, differentiability, and recursion induced by high-level requirements for training neural feedback controllers.

31

Back in 1991 I was using a C++ compiler with the earliest support for templates. 10,000 lines of code, using what was then called The STL (a 45k header file iirc), took 8 hours for a clean build. Why did it take so long? The first implementation was as follows: - compile - link - linking error ? Is it a missing template method ? Generate the code, compile, link Method by method. That was using an HP box, I think. The same code in Visual C++ 4.1 took 8 minutes.

3

1 Comment

Dear C++ community, Sometimes we need to write a logic around the C-like pointer, a simple RAII wrapper. # Example-1 https://lnkd.in/d483fvJY As you can see – it crashes, since we are passing the wrapper by the value into lambada object. We update the underlying pointer indeed – but, since the wrapper is passed by the value into capture list – constructor of the closure, the wrapper destructor will be called, as soon as lambda object goes out of scope (std::for_each algorithm). The simple solution would be to pass it by reference, but it still doesn’t solve the original problem – the fact that default copy-constructor of the wrapper object (CScope) leads to UB: since we have now two instances around the same pointer. Eventually, it causes double free issue. To solve this – we can, of course, use the smart pointer – with proper lifetime management. We can, for example, use thread-safe std::shared_ptr. Or, we can implement a light version of our own wrapper – with reference counting # Example-2 https://lnkd.in/dN2KZ_YB With two major differences: ● Deleter is, similar to std::unique_ptr, part of the class template instantiation: embedded into type definition. In std::shared_ptr implementation – it’s part of the control block ● It doesn’t have weak pointer reference counting (for circular dependency) If you are wondering, how would you implementd std::make_shared like functionality, that allocates in the same address space control block with underlying pointer, check this out # Example-3 https://lnkd.in/duDqfg3d What about custom allocators? Stay tuned, for the next posts. # When would we write our own RAII wrapper? In case that we have legacy code, or interact with a third party ( C ) library – like Apple's Core Foundation framework, with its own reference counting APIs: CFRetain/CFRelease, and we want to write our (C++) wrapper around CF* opaque types, generated with some CF specific factory methods. Fore more content, feel invited to follow me. You can also visit my blog ☛https://lnkd.in/dMPi7cvg Thanks in advance. #cpp #cplusplus #development

36

Doing some PID control testing for autonomous mobile robot, before all of the softwares are going to be moved to ROS2 framework and ROS2 node. This program will be written using micro-ROS to sent data to ROS2 node

3

Why Aren't C++20 and C++23 Fully Supported Yet? The Complexities of Compiler Development. ----------------------------------------------------- C++20 and C++23 brought a plethora of powerful features to the language, but full compiler support is still a work in progress. Why? Let's dive into the challenges faced by compiler developers: Feature Complexity: Modules, Concepts, Coroutines: These are just a few examples of features that demand significant changes to compiler architecture, type systems, and runtime environments. Implementing them correctly and efficiently takes time. Limited Resources: Compiler Teams: These teams have to balance implementing new features with maintaining existing code, fixing bugs, and addressing user feedback. Prioritization: Not all features are created equal. Some may be prioritized based on demand, impact, or ease of implementation. Implementation Hurdles: Legacy Code: Compilers must ensure backward compatibility with vast codebases, making it tricky to introduce new features without causing conflicts. Evolving Standards: The C++ standard is dynamic, requiring occasional adjustments to implementations as the standard gets clarified. Thorough Testing: Rigorous Testing: New features need extensive testing across different scenarios and platforms to ensure correctness. Real-World Feedback: User experiences with new features in real projects are crucial for uncovering potential issues. Other Factors: Compiler Variations: GCC, Clang, and MSVC have different implementation strategies and priorities. Third-Party Libraries: Many C++ projects rely on external libraries, which also need time to adopt and support new features. But there's good news! Compiler support for C++20 and C++23 is continuously improving. Start experimenting with supported features, stay informed about compiler updates, and provide feedback to help shape the future of C++. #CPP #C++20 #C++23 #CompilerDevelopment #SoftwareEngineering

9

This is a great Rust <-> C++ guide using cxx! I liked how Henk even ran cargo expand to demystify the macro. A follow-up showing how to use autocxx to generate the bridge automatically from headers would be a great addition to the suite of interop guides.

28

1 Comment

Do you know what an ONNX AI model is, and how important it is in C#? We use such cutting-edge technologies in MelkRadar | ملک‌رادار to develop awesome features. For learn how to use an ONNX model in C# look here: https://lnkd.in/en8_CGeQ #AI #CSharp #ONNX #C#

18