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 the 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* …
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 <typename T> void mySwapCopy(T& a, …
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 …
In chapter 12, we introduced the concept of value categories (), which is a property of expressions that helps determine whether an expression resolves to a value, function, or object. We also introduced l-values and r-values so that we could discuss l-value references. If you’re hazy on l-values and r-values, …
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: #include <iostream> class A { private: int m_x; public: A(int x) : m_x{x} { if (x <= 0) throw 1; // Exception thrown here …
Occasionally you may run into a case where you want to catch an exception, but not want to (or have the ability to) fully handle it at the point where you catch it. This is common when you want to log an error, but pass the issue along to the …
