2B. No Ducks Allowed – Templates and Deduction

Learning Objectives

By the end of this chapter, you will be able to:

• Develop your own classes to an even greater effect using inheritance and polymorphism
• Implement an alias to make your code easier to read
• Develop templates using SFINAE and constexpr to simplify your code
• Implement your own solutions using the STL to leverage generic programming
• Describe the context and basic rules for type deduction

This chapter will show you how to define and extend your types through inheritance, polymorphism, and templates.

Introduction

In the previous chapter, we learned how to develop our own types (classes) with the help of unit tests and made them behave like built-in types. We were introduced to function overloading, Rule of Three/Five, and Rule of Zero.

In this chapter, we will learn how to extend the type system even further. We'll learn how to create functions and classes using templates and revisit function overloading since it's impacted by the use of templates. We'll be introduced to a new technology, SFINAE, and use it to control the parts of our templates that are included in the generated code.

Inheritance, Polymorphism, and Interfaces

So far in our journey of object-oriented design and C++, we have focused on abstraction and data encapsulation. We will now turn our attention to inheritance and polymorphism. What is inheritance? What is polymorphism? Why do we need it? Consider the following three objects:

Figure 2B.1: Vehicle objects

In the preceding diagram, we can see that there are three very different objects. They have some things in common. They all have wheels (a different number), an engine (different size, power, or configuration), start engine, drive, apply brakes, stop engine, and so on, using which we can do something.

So, we can abstract them into something called a vehicle that demonstrates these attributes and general behaviors. If we express this as a C++ class, it might look like the following:

class Vehicle

{

public:

  Vehicle() = default;

  Vehicle(int numberWheels, int engineSize) :

        ...

Visibility, Lifetime, and Access

We have talked about creating our own types and declaring variables and functions while mainly focusing on simple functions and a single file. We will now look at what happens when there are multiple source files (translation units) that contain classes and function definitions. Also, we'll check which variables and functions can be visible from the other parts of the source files, how long the variables live, and look at the difference between internal and external linkage. In Chapter 1, Anatomy of Portable C++ Software, we saw how the toolchain works to compile the source files and produce the object files and that the the linker puts it all together to form an executable program.

When a compiler processes a source file, it generates an object file that contains the translated C++ code and enough information for the linker to resolve any references from the compiled source file to another source file. In Chapter 1, Anatomy of Portable C++ Software,...

Templates – Generic Programming

As a computer scientist, or as a programming enthusiast, at some point in time, you probably had to write one (or more) sort algorithms. When discussing the algorithm, you were not particularly concerned about the type of data being sorted, just that the two objects of that type could be compared and that the domain is a totally ordered set (that is, if one object is compared with any other, you can determine which comes first). Different programming languages provide different solutions to this problem:

• Python: A dynamic language with built-in function sort and member functions on list. As a dynamic language, it does not need to concern itself with the type if it can call the comparison operator and a swap function.
• C: This has a function in its standard library called qsort that has the following signature:

  void qsort (void* base, size_t num, size_t size,               ...

Type Aliases – typedef and using

If you have used the std::string class, then you have been using an alias. There are a few template classes related to strings that need to implement the same functionality. But the type representing a character is different. For example, for std::string, the representation is char, while std::wstring uses wchar_t. There are several others for char16_t and char32_t. Any variation in the functionality will be managed through traits or template specialization.

Prior to C++11, this would have been aliased from the std::basic_string base class, as follows:

namespace std {

  typedef basic_string<char> string;

}

This does two main things:

• Reduces the amount of typing required to declare the variable. This is a simple case, but when you declare a unique pointer to a map of strings to object, it can get very long and you will make errors:

  typedef std::unique_ptr<std::map<std::string,myClass>> UptrMapStrToClass;

• Improves the readability...

Templates – More than Generic Programming

Templates can also deliver much more than just generic programming (a cookie cutter with types). In the case of generic programming, the template operates as a blueprint that cannot be changed and delivers the compiled version of the template for the specified type or types.

Templates can be written to provide specialization of a function or algorithm based on the types involved. This is known as template specialization and is not generic programming in the sense we previously used it. It can only be called generic programming when it makes certain types behave as we would expect them to do in a given context. It cannot be called generic programming when the algorithm that's used for all types is modified.

Examine the following sample of specialization code:

#include <iostream>

#include <type_traits>

template <typename T, std::enable_if_t<sizeof(T) == 1, int> = 0>

void print(T val)

{

    printf("...

Class Templates

We have only dealt with function templates so far. But templates can also be used to provide blueprints for classes. The general structure of a templated class declaration is as follows:

template<class T>

class MyClass {

   // variables and methods that use T.

};

Whereas template functions allow us to produce generic algorithms, template classes allow us to produce generic data types and their associated behaviors.

When we introduced the Standard Template Library, we highlighted that it includes templates for containers – vector, deque, stack, and so on. These templates allow us to store and manage any data type that we want, but still behave as we would expect.

Exercise 4: Writing a Class Template

Two of the most commonly used data structures in computing science are stack and queue. Both currently have implementations in the STL. But to get our feet wet with a templated class, we are going to write a stack template class that can be used for any type...

Summary

In this chapter, we learned about interfaces, inheritance, and polymorphism, which extended our skills of what we can do with our types. We had our first adventure into generic programming with C++ templates and touched on what the language gives us for free from the C++ Standard Library, which includes the STL. We explored a feature of C++ that just works, that is, template type deduction, which makes our life easier when using templates. We then went further with templates and learned how to control the parts of the template that are included by the compiler using SFINAE and if constexpr. These form the building blocks for our journey into C++. In the next chapter, we will revisit the stack and the heap, and understand what an exception is, what happens, and when it occurs. We'll also learn how to protect our programs from resource losses when exceptions occur.