Garbage Collection – No Thanks
C++ is old-fashioned. C++ has no garbage collection. No garbage collection? Right! Old fashioned? Wrong!
Author Archive for: admin
Entries by Rainer Grimm
Perfect Forwarding
Today, we solve ” … a herefore unsolved problem in C++” (Bjarne Stroustrup). To make the long story short, I will write about perfect forwarding.
Time for Wishes
I wrote more than 130 posts in my German blog about functional programming, embedded programming and multithreading programming with modern C++. My English blog will catch up in two months with my German one. Therefore, it’s the right time to rework my blogs. The German blog and the English blog in parallel.
Move Semantis: Two Nice Properties
I will talk about two nice properties of the move semantic in this post that is not so often mentioned. Containers of the standard template library (STL) can have non-copyable elements. The copy semantic is the fallback for the move semantic. Irritated? I hope so!
Copy versus Move Semantics: A few Numbers
A lot was written about the advantages of move semantics to copy semantics. Instead of an expensive copy operation, you can use a cheap move operation. But what does that mean? In this post, I will compare the copy and move semantics performance for the Standard Template Library (STL) containers.
std::array – Dynamic Memory, no Thanks
std::array combines the best of two worlds. On the one hand, std::array has the size and efficiency of a C array; on the other hand, std::array has the interface of a std::vector.
Automatic Memory Management of the STL Containers
One of the significant advantages of a C++ string to a C string and of a std::vector to a C array is that both C++ containers automatically manage their memory. Of course, that holds for all further containers of the Standard Template Library. In this post, I will look closer at the automatic memory management […]
std::weak_ptr
std::unique_ptr models the concept of exclusive ownership, std::shared_ptr the concept of shared ownership. If I stick to this picture then std::weak_ptr models the concept of temporary ownership because it borrows the resource from a std::shared_ptr. There is one dominant reason for having a std::weak_ptr in C++: breaking of cyclic references of std::shared_ptr‘s.
Specialities of std::shared_ptr
After I draw the big picture of a std::shared_ptr in the last post, I want to present two special aspects of this smart pointer in this post. First, I show with std::shared_from_this how to create a std::shared_ptr from an object; second, I’m interested in the question to the answer: Should a function take a std::shared_ptr […]
std::shared_ptr
std::shared_ptr’s share the resource. The shared reference counter counts the number of owners. Copying a std::shared_ptr increases the reference count by one. Destroying a std::shared_ptr decreases the reference count by one. If the reference count becomes zero, the resource will automatically be released.