2CPP15 - Templates

Introduction
• In a previous lecture we talked very briefly about the idea
of parametric polymorphism.
• Being able to treat specific types of object independent of what
they actually are.
• In this lecture we are going to talk about C++’s templating
system.
• This lets us incorporate parametric polymorphism correctly in our
programs.

The Problem
• Say we want to create a basic kind of data structure.
• A queue
• A stack
• A hashmap
• How do we do that and still be able to deal with object
orientation?
• Answer is not immediately straightforward.

Java, Pre 1.5
• Many kinds of standard data structures exist as the
standard libraries in Java.
• Such as ArrayLists.
• Before version 1.5, the following syntax was used.
• Requires explicit casting of objects as they come off of the structure.
• Why?
• Polymorphism
Arraylist list = new ArrayList();
String str;
list.add (“Bing”);
list.add (“Bong”);
str = (String)list.get(0);

Java, 1.5+
• New versions of Java work with a different, more
demonic syntax.
• Explicit type information recorded along with the structure.
• No need for casting as things come off of the structure.
• How is such a thing achieved??
Arraylist<String> list = new ArrayList<String>();
String str;
list.add (“Bing”);
list.add (“Bong”);
str = list.get(0);

Generics/Templates
• The system in Java and C# is known as the
generics system.
• In C++, it’s called Templating.
• Both systems are roughly equivalent.
• Used for the same purpose, with various technical
differences.
• Templates more powerful than the Java/C# implementation.
• Provides a method for type-casting structures to permit
more elegant syntactic representation.
• Permits compile time checking of homogenous
consistency.

How Do They Work?
• Code we provide serves as a template for C++ to
generate specific instances of the code.
• Works like a structure that can deal with data at a family level of
granularity.
• Exists in two kinds:
• Function templates
• Class templates

Function Templates
• Function templates mimic a more flexible form of
method overloading.
• Overloading requires a method to be implemented for
all possible types of data.
• Function templates allow us to resolve that down
to a single template definition.
• Compiler can analyse provided parameters to
assess the function that must be created.
• Within limits… cannot interpret functionality where it
isn’t syntactically valid.

Function Templates
template <class T>
T add_nums(T a, T b);
#include <iostream>
#include "TemplateTest.h"
using namespace std;
template <typename T>
T add_nums(T num1, T num2)
{
return num1+num2;
}
int main() {
cout << add_nums ('a', 1) << endl;
return 0;
}

Ambiguity
• Because it is the compiler doing the work of interpreting
parameters, it cannot deal well with ambiguity.
• Where we say T, we must have it apply consistently across a
function call.
• We can ensure a certain kind of template being called by
type-casting the function call.

Ambiguous Function Call
#include <iostream>
{
return num1+num2;
}
int main() {
cout << add_nums (2.0f, 1) << endl;
return 0;
}

Non-Ambiguous Function Call
#include <iostream>
{
return num1+num2;
}
int main() {
cout << add_nums<float> (2.0f, 1) << endl;
return 0;
}

Multi-Type Functions
#include <iostream>
template <typename T, typename S>
T add_nums(T num1, S num2)
{
return num1+num2;
}
int main() {
float f;
f = add_nums<float, int> (5.0f, 3);
cout << f << endl;
return 0;
}

Class Templates
• In a similar way, we can create templates for C++
classes that are type agnostic.
• Again, the compiler will infer typing from context where
it possibility can.
• Good design in C++ separates out definition and
implementation.
• Into .h and .cpp files.
• Slight problem with doing this the way we have
done previously.
• It won’t work.

Class Templates
• Templates are not real code.
• Not as we understand it.
• It’s like a template letter in a word processor.
• Until the details are filled in, it’s not an actual letter.
• When separating out the definitions, the compiler
can’t deal with the T until it knows what types it’s
working with.
• The code doesn’t exist until you use it.
• This causes linking problems in the compiler.

Class Template Problems
• The complete definition for a function must be available at
the point of use.
• If the full definition isn’t available, the compiler assumes it has been
defined elsewhere.
• In the main program, it knows the type of the data type we
want to use.
• In the definition file, it doesn’t.
• So it never generates the appropriate code.
• Solution – inline functions.

A Stack Template
class Stack {
private:
T *stack;
int current_size;
public:
Stack() :
stack (new T[100]),
current_size (0) {
}
void push(T thing) {
if (current_size == 100) {
return;
}
stack[current_size] = thing;
current_size += 1;
}

A Stack Template
T pop() {
T tmp;
current_size -= 1;
tmp = stack[current_size];
return tmp;
}
void clear() {
current_size = 0;
}
int query_size() {
return current_size;
}
~Stack() {
delete[] stack;
}
};

Using The Stack
#include <iostream>
#include <String>
#include "Stack.h"
int main() {
Stack<int> *myStack;
myStack = new
Stack<int>();
myStack->push (100);
cout << myStack->pop()
<<
endl;
return 0;
}
#include <iostream>
#include <String>
#include "Stack.h"
int main() {
Stack<string> *myStack;
myStack = new
Stack<string>();
myStack->push ("Hello");
cout << myStack->pop() <<
endl;
return 0;
}

Benefits of Templates
• Templates allow us to have classes and functions that
work independently of the data they use.
• No need to write a hundred different stacks, just write one using a
template.
• No significant performance overhead.
• It takes a little time for the compiler to generate the actionable
code, but it is not significant.

Qualified and Unqualified Names
• What does the typename keyword mean in C++?
• Have to go back quite a ways to explain this!
• Remember in our first header files, we’d often tell
them to use a namspace?
• To get access to the string class for one example.
• This is not good practice.
• We tell every class that uses the header to make use of
that namespace.

Qualified Names
• Qualified names are those that specifically note a
scope in a reference.
• For example, string is defined in std, thus:
• std::string
• std::cout
• Scope is independent of using a namespace
#include <iostream>
int main() {
std::cout << "Bing!" << std::endl;
return 0;
}

The Problem
template<class S>
void do_something()
{
S::x1 * x2;
}
What are we doing here?
Accessing a member variable called X1 in the parametrized class S?
Or…
Creating a pointer of type S::x1, with the name x2?
Typename resolves this problem.

One Last Thing…
• It’s often important to handle deep copies in templates.
• For the same reason it’s important in normal classes.
• Must include copy constructors and assignment operators
here.
• Remember the rules regarding these with reference to pointers and
others.

Deep Copies on Templates
Stack<T>(const Stack<T> &s) {
current_size = s.current_size;
stack = new T[100];
for (int i = 0; i < 100; i++) {
stack[i] = s.stack[i];
}
}
Remember these are designed to work on value objects and must be explicitly
de-referenced when working with pointers, like so:
Stack<string> *myStack, *stack2;
myStack = new Stack<string>;
stack2 = new Stack<string>(*myStack);

Deep Copies on Templates
Stack<T>& operator= (const Stack<T> &s) {
current_size = s.current_size;
delete[] stack;
stack = new T[100];
for (int i = 0; i < 100; i++) {
stack[i] = s.stack[i];
}
return (*this);
}

Summary
• Method overloading offers a degree of ad hoc
polymorphism.
• Combinations must be specified initially.
• Templates permit for parametric polymorphism.
• More complex, but a powerful way of creating generic data types.
• We’ll see the power of this in the next lecture.

2CPP15 - Templates

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (8)

Similaire à 2CPP15 - Templates

Similaire à 2CPP15 - Templates (20)

Plus de Michael Heron

Plus de Michael Heron (20)

Dernier

Dernier (20)

2CPP15 - Templates