![\"RessourcenmanagementEng\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2016\/12\/RessourcenmanagementEng.png\")
<\/p>\nThe careful handling of resources – may it be, for example, memory, files, or sockets – is a key concern of programming in C++. This holds, in particular, true for embedded programming, which is often characterized by limited resources. Therefore, I will write a few posts about this challenging and versatile topic.<\/p>\n
<\/p>\n
<\/p>\n
In my first attempt to write this post, I wanted to jump directly into the memory allocation with operator new. Fortunately, I went a few steps back. Memory management is only one but admittedly an important component of resource management in C++. The story is a lot more versatile. So I want to write about three domains of resource management in C++.<\/p>\n
There is automatic memory management in C++ that is relatively easy to use. In addition, we have the well-known idioms in C++ that are the base of automatic memory management. At last, C++ offers explicit memory management in which the user has full power. I will follow these three steps in my post because I don’t want to create the impression that explicit memory management is basic knowledge for the C++ developer.<\/p>\n
<\/p>\n
I start at the basic level with smart pointers.<\/p>\n
C++ has four different smart pointers. Each of them has the task of taking care of the lifetime of its underlying resource. The std::unique_ptr<\/span> takes ownership of the lifetime of one resource explicitly. A std::shared_ptr<\/span> shares the ownership of a resource with the other std::shared_ptr<\/span>‘s. Therefore, cycles can appear and the resource can not automatically be released. It’s the job of the std::weak_ptr<\/span> to break these cycles. The last one is the with C++11 deprecated std::auto_ptr.<\/span> Why? You will see it in a later post.<\/p>\n STL container cont<\/span> like <\/span>std::vector<\/span> or std::string<\/span> automatically manages their memory. E.g., they have a method cont.push_back <\/span>to add a new element to the container. The size of the container will automatically grow. But it also works the other way around. Thanks to cont.shrink_to_fit,<\/span> the container will be reduced to its size.<\/p>\n<\/p>\n Each modern STL implementation uses the C++ idioms to move semantic, perfect forwarding, and the RAII idiom very often. To understand the underlying mechanism, we must dig deeper into automatic memory management details. Before I write about the C++ idioms, here is a small appetizer.<\/p>\n The critical idea of move semantics is simple: use cheap move operations instead of expensive copy operations for big objects. This holds, in particular, true for such objects that can not be copied. A typical example is a std::mutex<\/span> or a std::unique_ptr.<\/span><\/p>\n Perfect forwarding uses under-the-hood similar techniques like the move semantic. The key idea of perfect forwarding is a different one. The job of perfect forwarding is to take arguments in a function template and forward them identically. The typical use case is constructors that forward their argument to the base class constructor or factory methods that create new objects.<\/p>\n The idea of the RAII idiom is quite simple. You bind a resource’s acquisition and release to the lifetime of a local object. Therefore, the resource will automatically be initialized in the constructor and released in the destructor. The acronym RAII stands for R<\/strong>esource A<\/strong>cquisition I<\/strong>s I<\/strong>nitialization. Smart pointers and locks implement this technique.<\/p>\n Now we are in the domain of the experts. Thanks to the explicit memory management in C++, it is possible the tailor memory management to your needs. You can adjust it to simple objects or arrays, but you can also adjust it on a class or global level. You can write your memory allocators and use them with the help of placement new. <\/span><\/p>\nSTL container<\/h3>\n
C++ idioms<\/h2>\n
Move semantic<\/h3>\n
Perfect forwarding<\/h3>\n
RAII idiom<\/h3>\n
Explicit memory management<\/h2>\n
What’s next?<\/h2>\n