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 …
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 …
Consider the following short program: #include <iostream> enum class FruitType { apple, banana, cherry }; class Fruit { private: FruitType m_type {}; int m_percentageEaten { 0 }; public: Fruit(FruitType type) : m_type { type } { } FruitType getType() const { return m_type; } int getPercentageEaten() const { return m_percentageEaten; …
Templates allow us to write functions or classes using placeholder types, so that we can stencil out identical versions of the function or class using different types. A function or class that has been instantiated is called a function or class instance. All template functions or classes must start with …
In previous lesson , we took a look at a simple templated Storage class: #include <iostream> template <typename T> class Storage { private: T m_value; public: Storage(T value) : m_value { value } { } ~Storage() { } void print() const { std::cout << m_value << ‘\n’; } }; We …
When instantiating a function template for a given type, the compiler stencils out a copy of the templated function and replaces the template type parameters with the actual types used in the variable declaration. This means a particular function will have the same implementation details for each instanced type (just …
