This Week C++ Templates

Another form of polymorphism (interface based) Let you plug different types into reusable code

CSE 332: C++ templates

Overview of C++ Templates

Templates are used to plug in different types
Can re-use same code with int, string, etc.

Also called type parameterization

Types are given as parameters to a template Like variables are given as a functions parameters

Can make templates for functions and classes

The user of a class template must declare the type parameters when declaring an instance Dont have to declare the type parameters when calling a function template (call as though a non-template function)
The compiler figures it out for you, based on function call signature

CSE 332: C++ templates

Files for C++ Templates

Keep declarations and definitions separate
Just as you would for non-template classes and functions Have separate header (declarations) and source (definitions) files

Separate template and non-template code

For example, if a template relates to a class, put template in header and source files with similar (but different) names
array.h array.cc array_T.h array_T.cc

Some compilers (like g++) require that template definitions be included with their declarations
// . . . at the end of array_T.h #if defined (TEMPLATES_REQUIRE_SOURCE) #include "array_T.cc" #endif /* TEMPLATES_REQUIRE_SOURCE */ #endif /* ARRAY_T_H */

CSE 332: C++ templates

Introduction to Function Templates

template <typename T> void swap(T &lhs, T &rhs) { T temp = lhs; lhs = rhs; rhs = temp; } int main () { int i = 3; int j = 7; swap (i,j); return 0; }

Basic idea
same code is re-used for different types

Function template swap

takes one type parameter, T

Definition interchanges values of two passed arguments

of the parameterized type

Compiler infers type is really int when swap is called Compiler instantiates the function template definition using type int

CSE 332: C++ templates

Introduction to Class Templates

template <typename T> class Array { public: Array(const int size); ~Array(); private: T * values_; const int size_; };
int main() { Array<int> a(10); Array<string> b(5); return 0; }

Parameterized type T must be specified in class template declaration

Both as a parameter, and where its used in the class

When an instance is declared, must also explicitly specify the concrete type parameter
E.g., int vs. string in function main() In previous function template example, didnt have to say swap<int>

CSE 332: C++ templates

Tips on Using Function and Class Templates

Push common code and variables up into nontemplate base classes
Gives compiler less work to do instantiating templates Reduces program size and compilation time

Use function templates when you want type parameterization to be invisible to programmer
To force an explicit declaration of the parameterized type, use member functions of class templates instead

Use class templates when you want to parameterize member variables types
Lots of containers in the STL do this (vector, list, etc.) Well talk about the STL and how it uses templates later in the semester
CSE 332: C++ templates

Templates Have a Different View of Types

template <typename T> void swap(T &lhs, T &rhs) { T temp = lhs; lhs = rhs; rhs = temp; } int main () { int i = 3; int j = 7;
swap (i,j); return 0; }

Look at what swap requires of its parameterized types

Copy construction T temp = lhs; Assignment lhs = rhs; rhs = temp;

These requirements are called a templates concept A type that meets those requirements is called a model of that concept Can substitute any type that models a templates concept

CSE 332: C++ templates

Inheritance vs. Concept Refinement

Class1 Concept1
inherits from

T1

T2

T1

T2

refines

Class2
is an instance of models

Concept2 T3 T4

T3

T4

Explicit inheritance relation between classes

Class2 advertises its parent, Class1

Implicit refinement relation between concepts

Concept2 adds to the requirements of Concept1
CSE 332: C++ templates

Inheritance vs. Concept Refinement, part II Similarities

Both define a type hierarchy (a partial order)
Reflexive and transitive, but not symmetric Can be expressed as a directed acyclic graph Can be used by a compiler to do type checking

Both support type substitution, polymorphism

Differences
Again, refinement is implicit, inheritance is explicit
Programmer must define all inheritance relationships C++ compiler infers concept/models relationships for us

Type substitution and polymorphism mechanisms

CSE 332: C++ templates

OO vs. Generic Programming Paradigms

Liskov Substitution Principle
If S is a subtype of type T (S meets all the requirements of T), then whenever we need an instance of T we can substitute an instance of S.

Object-Oriented (OO) Programming: Public Inheritance

class Derived: public Base { }; void foo (Base &b); Derived d; foo (d);

Generic Programming: Concepts, Models, Refinement

Class A only supports default construction Class B supports assignment and copy construction as well as all other operators A support Can use B in any template whose concept A models Cannot use A in any template whose concept B models

CSE 332: C++ templates

Extending Interfaces
Substitution is often non-symmetric
S replaces T, but not vice versa Often due to S extending the interface T provides

In OO Programming: Public Inheritance

class Base {public: void baz ();}; // Base only has baz class Derived: public Base {public: void bar ();}; // S adds bar

In Generic Programming: Concept Refinement

An STL random access iterator provides +=, -=, and ++
For example, an iterator using a pointer into an array

An STL forward iterator provides ++ but some forward iterators may not provide += or -=
For example an iterator using a pointer into a linked list

CSE 332: C++ templates

Polymorphism with Templates Substitution may provide different behaviors

Poly = many + Morph = form When we can substitute types, we want to get specialized behaviors when using different types

In OO programming
Derived classes can override base class behaviors Using virtual functions, we get polymorphism

Can we do something similar with Concepts and types that model them in templates?
I.e., so we get customized behavior for specific (more refined) templates?
CSE 332: C++ templates

Specializing Behaviors of Types

What mechanisms are available in C++?
With OO programming
We combine public inheritance & virtual methods:
class Base {public: virtual void foo () {cout << Base;} }; class Derived : public Base {virtual void foo () {cout << Derived;}};

With Generic programming

We combine operator/function overloading with template specialization mechanisms Sometimes called interface polymorphism
CSE 332: C++ templates

Template Specialization Allows us to override behaviors

Of function templates or class templates

Can override default (base) behavior:

template <typename T> print (T t) {cout << t << endl;} template <> print <char *> (char * str) {cout << (void *) str << endl;}

Partial specialization possible (some compilers)

Leave types of some parameters unspecified While specializing on explicit types for others E.g., on a null_guard type to remove acquire and release overhead if no dynamic allocation is done
CSE 332: C++ templates

Review Questions
How are inheritance-based (OO) and interfacebased (generic) substitution similar, and how do they differ? What are the similarities and differences between type polymorphism with inheritance (OO) and with concepts (generic)? How does C++ template specialization work? How do you declare/define a generic template, and different specializations of it?
CSE 332: C++ templates