In the previous lesson, we saw how std::shared_ptr allowed us to have multiple smart pointers co-owning the same resource. However, in certain cases, this can become problematic. Consider the following case, where the shared pointers in two separate objects each point at the other object: #include <iostream> #include <memory> // …
Unlike std::unique_ptr, which is designed to singly own and manage a resource, std::shared_ptr is meant to solve the case where you need multiple smart pointers co-owning a resource. This means that it is fine to have multiple std::shared_ptr pointing to the same resource. Internally, std::shared_ptr keeps track of how many …
At the beginning of the chapter, we discussed how use of pointers can lead to bugs and memory leaks in some situations. For example, this can happen when a function early returns, or throws an exception, and the pointer is not properly deleted. #include <iostream> void someFunction() { auto* ptr{ …
Consider a fixed array of integers in C++: int array[5]; If we want to initialize this array with values, we can do so directly via the initializer list syntax: #include <iostream> int main() { int array[] { 5, 4, 3, 2, 1 }; // initializer list for (auto i : …
Once you start using move semantics more regularly, you’ll start to find cases where you want to invoke move semantics, but the objects you have to work with are l-values, not r-values. Consider the following swap function as an example: #include <iostream> #include <string> template<class T> void myswap(T& a, T& …
In lesson , we took a look at std::auto_ptr, discussed the desire for move semantics, and took a look at some of the downsides that occur when functions designed for copy semantics (copy constructors and copy assignment operators) are redefined to implement move semantics. In this lesson, we’ll take a …
Way back in chapter 1, we mentioned l-values and r-values, and then told you not to worry that much about them. That was fair advice prior to C++11. But understanding move semantics in C++11 requires a re-examination of the topic. So let’s do that now. L-values and r-values Despite having …
Consider a function in which we dynamically allocate a value: void someFunction() { Resource *ptr = new Resource(); // Resource is a struct or class // do stuff with ptr here delete ptr; } Although the above code seems fairly straightforward, it’s fairly easy to forget to deallocate ptr. Even …
Chapter review Exception handling provides a mechanism to decouple handling of errors or other exceptional circumstances from the typical control flow of your code. This allows more freedom to handle errors when and how ever is most useful for a given situation, alleviating many (if not all) of the messiness …
Try and catch blocks work well enough in most cases, but there is one particular case in which they are not sufficient. Consider the following example: class A { private: int m_x; public: A(int x) : m_x{x} { if (x <= 0) throw 1; } }; class B : public …
