In the previous lesson (), we discussed how an lvalue reference can only bind to a modifiable lvalue. This means the following is illegal: int main() { const int x { 5 }; // x is a non-modifiable (const) lvalue int& ref { x }; // error: ref can not …
In a function that takes parameters, the caller may be able to pass in arguments that are syntactically valid but semantically meaningless. For example, in the previous lesson (), we showed the following sample function: void printDivision(int x, int y) { if (y != 0) std::cout << static_cast<double>(x) / y; …
A smart pointer class is a composition class that is designed to manage dynamically allocated memory, and ensure that memory gets deleted when the smart pointer object goes out of scope. Copy semantics allow our classes to be copied. This is done primarily via the copy constructor and copy assignment …
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 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, …
