One of the greatest strengths of C++ is its support for generic programming. In generic programming, the algorithms and data structures are written in terms of generic types that will be specified later. This allows the programmer to implement a function or a class once, and later, instantiate it for many different types. Templates are a C++ feature that allows classes and functions to be defined on generic types. C++ supports three kinds of templates—function, class, and variable templates.

Function templates are generic functions—unlike the regular functions, a template function does not declare its argument types. Instead, the types are template parameters:

template &lt...

The template name is not a type and cannot be used to declare a variable or call a function. To create a type or a function, the template must be instantiated. Most of the time, the templates are instantiated implicitly when they are used. We will again start with the function templates.

To use a function template to generate a function, we have to specify which types should be used for all template type parameters. We can just specify the types directly:

template <typename T>
T half(T x) { return x/2; }
int i = half<int>(5);

This instantiates the half function template with the int type. The type is explicitly specified; we could call the function with an argument of another...

Template specializations allow us to make the generated template code differently for some types—not just the same code with different types substituted, but completely different code. There are two kinds of template specialization in C++—the explicit, or full, specialization and the partial specialization. Let's start with the former.

Explicit template specialization defines a special version of the template for a particular set of types. In an explicit specialization, all generic types are replaced by specific, concrete types. Since the explicit specialization is not a generic class or function, it does not need to be instantiated later. For the same reason...

We are used to regular functions, or class methods, being overloaded—multiple functions with the same name have different parameter types. Each call invokes the function with the best match of the parameter types to the call arguments, as show in the following example:

void whatami(int x) { std::cout << x << " is int" << std::endl; }
void whatami(long x) { std::cout << x << " is long" << std::endl; }
whatami(5);      // 5 is int
whatami(5.0);    // Compilation error 

If the arguments are a perfect match for one of the overloaded functions with the given name, that function is called. Otherwise, the compiler considers conversions to the parameter types of the available functions. If one of the functions offers better conversions, that function is selected. Otherwise, the call is ambiguous...

Probably the greatest difference between generic programming in C and C++ is type safety. It is possible to write generic code in C—the standard function qsort() is a perfect example—it can sort values of any type and they are passed in using a void* pointer, which can really be a pointer to any type. Of course, the programmer has to know what the real type is and cast the pointer to the right type. In a generic C++ program, the types are either explicitly specified or deduced at the time of the instantiation, and the type system for generic types is as strong as it is for regular types. Unless we want a function with an unknown number of arguments, that is, prior to C++11, the only way was the old C-style variadic functions where the compiler had no idea what the argument types were; the programmer just had to know and unpack the variable arguments...

In C++, the regular function syntax is extended with the concept of a callable, short for callable entity—a callable is something that can be called in the same way as a function. Some examples of callables are functions (of course), function pointers, or objects with operator(), also known as functors:

void f(int i);
struct G {
    void operator()(int i);
};
f(5);            // Function
G g; g(5);       // Functor

It is often useful to define a callable entity in a local context, right next to the place it is used. For example, to sort a sequence of objects, we may want to define a custom comparison function. We can use an ordinary function for this:

bool compare(int i, int j) { return i < j; }
void do_work() {
    std::vector<int> v;
    .....
    std::sort(v.begin(), v.end(), compare);
}

However, in C++, functions cannot be defined inside other functions...

Templates, variadic templates, and lambda expressions are all powerful features of C++, offering simplicity in use, but are rich in complex details. The examples in this chapter should serve to prepare the reader for the later chapters of this book, where we use these techniques to implement design patterns, both classic and novel, with the tools of the modern C++ language. The reader wishing to learn the art of using these complex and powerful tools to their fullest potential is referred to other books that are dedicated to teaching these subjects, some of which can be found at the end of this chapter.

The reader is now ready to learn the common C++ idioms, starting with the idioms for expressing memory ownership, in the next chapter.

1. What is the difference between a type and a template?
2. What kind of templates does C++ have?
3. What kinds of template parameters do C++ templates have?
4. What is the difference between a template specialization and a template instantiation?
5. How can you access the parameter pack of the variadic template?
6. What are lambda expressions used for?

• C++ Fundamentals:https://www.packtpub.com/application-development/c-fundamentals
• C++ Data Structures and Algorithms: https://www.packtpub.com/application-development/c-data-structures-and-algorithms
• Mastering C++ Programming: https://www.packtpub.com/application-development/mastering-c-programming