Lecture 5. Basics Part 4

Computer Methods 3
ENEL3CCH1
Week Five
Recap of Week 4
Explicit and Implicit specialisation
Member function templates
Class templates
Discipline of Electrical, Electronic & Computer Engineering Bashan Naidoo
What we cover in week 5
• We look at template instantiation

• Implicit specialisation
• Explicit specialisation
• We look at simple templated OOP coding...

• Template member functions in normal classes
• Template classes with normal member functions
• Template classes with template member functions
• The Inclusion Model for templated class code organisation
• We deploy code samples at each step

Aside: Pointers and references
Let us now consider another variable of type “pointer to int”…
this is x
We can now dereference the pointer: *xptr = 20;
The dereferencing operator * takes an initialised pointer and returns the object it is pointing to
name: xptr address: &xptr type: int* value: &x size: 4 bytes of memory
Somewhere in memory Somewhere else in

memory
&xptr > xptr = &x; &x >
&x xptr 20 x
Aside: Pointers and references
Let us consider references…
Now we use the reference: int &xref = x;

xref = 40;
Somewhere in
memory
&x >
40 x xref
Function overloading and templates
• This template
#include <iostream> replaces all the
#include <string> overloaded
definitions of
NTswap().
/******************Function templates******************
* Since the structure and logic are identical in all *
* above functions, we can replace them with a single * • This must precede
* function template... below * main()
******************************************************/
• It can even process
template <typename T> strings
void NTswap(T &Num1, T &Num2) {
T temp = Num1;
Num1 = Num2; Note: These are
Num2 = temp; ordinary functions (not
} methods), and this is a
POP example (not OOP)
From the compiler’s perspective…
• A template is not a normal function or class.
• It cannot be directly compiled. Why?
A single template represents a whole set of functions

Each function is a specialisation of the template
Generic single
template template
instantiation instantiation instantiation
Specific
Function template template template
(specialisaions) specialisation specialisation specialisation
Instantiation of
specialisations From the compiler’s perspective…
Template • Templates must be converted to specialisations

(not • Then specialisations may be compiled
compileable)
• The conversion process is called instantiation
• Instantiation may follow two routes
• Implicit specialisation (where possible)
instantiation • Explicit specialisation (always possible)
Specialisation
(compileable
C++ code)
Implicit instantiation of Implicit Specialisation Example #include <iostream>
specialisations typename using namespace std;
template <class T> template <class T>

Template T GetMax (T a, T b) { T GetMax (T a, T b) {
return (a>b?a:b); return (a>b?a:b);
} }
k =GetMax(i,j); n =GetMax(l,m); int main () {

instantiation int i=5, j=6, k;
long l=10, m=5, n;
k =GetMax(i,j);
n=GetMax(l,m);
int GetMax (int a, int b) { long GetMax (long a, long b) {
cout << k << endl;
cout << n << endl;
} }
return 0;
Specialisation }
Compileable C++ code
Explicit instantiation of Explicit Specialisation Example #include <iostream>
specialisations using namespace std;
template <class T> template <class T>

Template T GetMax (T a, T b) { T GetMax (T a, T b) {
} }
int main () {
instantiation int i=5, j=6, k;
k =GetMax<int>(i,j); n =GetMax<long>(l,m); long l=10, m=5, n;
k =GetMax< int >(i,j);
n=GetMax< long >(l,m);
int GetMax (int a, int b) { long GetMax (long a, long b) {
cout << k << endl;
cout << n << endl;
} }
return 0;
Specialisation }
Explicit instantiation of Explicit Specialisation Example
specialisations (multiple template parameters) //code frag from main()
Template template <class T, class U> int i,j;

T GetMin (T a, U b) { long l;
return (a<b?a:b); i = GetMin<int,long> (j,l);
}
instantiation OOPS!
i = GetMin<int,long> (j,l); Exercise for you!
The function returns an
int. Can it return b as
int GetMin (int a, long b) { an int? Will this
return (a<b?a:b); compile? You test this
} and fix it if needed.
Specialisation
Introduction to templates in OOP
So we have already looked at…
• Function overloading
• Function templates
• Instantiation of implicit and explicit template specialisations
These were presented as simple POP concepts where a main program calls
an overloaded function or a template, that is defined outside of main().
Remember… function templates are just special cases of function

overloading.
We now look at the basics of templates in the OOP paradigm

Introduction to templates in OOP
We now look at the basics of templates in the OOP paradigm…
More specifically, we will look at:
• Member function templates and
• Class templates
This gets complex very quickly, so we only do the basics.

Remember that this module is not about C++. It just uses C++
A class definition can contain member function templates
Assume that we have defined a class with public member functions…

We can insert a public function template into that class
This member function template will be specialised when the class is
instantiated.
…and NOT when the
function is called.
Examples follow…
Lets start with a simple OOP example (no templates yet)
#include <iostream> Output:
class MFTdemo1 { OBJ1.ModMyVar(3) = 9

public:
int ModMyVar(int var) {
return 3 * var;
} No surprises here. Output is
}; as expected…
int main()
{
MFTdemo1 OBJ1;
std::cout << "OBJ1.ModMyVar(3) = " << OBJ1.ModMyVar(3) << "\n";
}
Major limitation: Can only
use integer values!!!
Now we convert member function into a member template and test it
#include <iostream> This is a normal class Output:
with a public
class MFTdemo2 { template member OBJ2.ModMyVar(3) = 9
public: function OBJ2.ModMyVar(3.6) = 10.8
template<typename T>
T ModMyVar(T var) {
return 3 * var; Implicit specialisation of
} the member function
}; template has produced the
desired output…
int main()
{
MFTdemo2 OBJ2;
std::cout << "OBJ2.ModMyVar(3.6) = " << OBJ2.ModMyVar(3.6) << "\n";
} Problem Sorted!
Now we convert member function into a member template and test it
#include <iostream>
Complexity is shifted Output:
into the class
class MFTdemo2 {
Remember… OBJ2.ModMyVar(3) = 9
public:
• ******Abstraction****** OBJ2.ModMyVar(3.6) = 10.8
• Write once, use many
T ModMyVar(T var) {
return 3 * var;
} Simple, happy calling program
}; Totally blind to the hidden complexity
Remember:
int main() • One class definition, many instances!
{ • Write once (complex), use many (simple)
MFTdemo2 OBJ2;
}
An alternate syntax for the template member function
#include <iostream>
This is a normal class Output:
class MFTdemo2 {
with a public template
public: OBJ2.ModMyVar(3.6) = 10.8
member declaration
T ModMyVar(T var);
};
The template member function is just like a
template<typename T> free template function but…
T MFTdemo2::ModMyVar(T var) { it is declared inside the containing class, and
return 3 * var; its external definition is scoped to its
} containing class.
int main(){
MFTdemo2 OBJ2;
}
Now we combine and test template and non-template member overloads
class MFTdemo3 {
public: This is a normal class Output:
int ModMyVar(int var) { with template and non-
return 5 * var; template overloads of OBJ3.ModMyVar(3) = 15
} ModMyVar() OBJ3.ModMyVar(3.6) = 10.8
T ModMyVar(T var) {
return 3 * var; Executes the non-template Executes the template
} member function if it member function. A non-
}; exists; which is the case. template overload does not
(output = 5 * 3) exist (output = 3 * 3.6)
int main() {
MFTdemo3 OBJ3;
}
Class templates
Class templates are similar to function templates
• Can be done if we have class overloads with the same logic

and structure, but with different datatypes.
• Class templates allow us to create a generic class definition,

which in turn may be instantiated to various specialisations.
• Each specialisation will have the same logic and structure, but
will have unique datatypes (like the overloads it replaces).
Class templates
First we look at a normal class…
Output:
#include <iostream>
My height is 183 cm.
class Measurement {
private:
int value;
public:
int getValue() { return value; }
void setValue(int val) { value = val; }
};
int main() {
Measurement heightCM;
heightCM.setValue(183);
std::cout << "My height is " << heightCM.getValue() << " cm.\n";
}
Class templates
Convert it to a class template…
Output:
#include <iostream>
template<typename T> My height is 183 cm.
class Measurement {
private:
T value;
public: We are forced to use
T getValue() { return value; } EXPLICIT specialisation.
void setValue(T val) { value = val; } Can you explain why?
};
int main() {
Measurement<int> heightCM;
heightCM.setValue(183);
std::cout << "My height is " << heightCM.getValue() << " cm.\n";
}
Class templates
class Measurement {
private:
T value;
public:
T getValue() { return value; }
void setValue(T val) { value = val; }
};
Measurement<int> heightCM; Measurement<double> heightM;
class Measurement <int> { class Measurement <double> {

private: private:
int value; double value;
public: public:
int getValue() { return value; } double getValue() { return value; }
void setValue(int val) { value = val; } void setValue(double val) { value = val; }
}; };
class type is: Measurement<int> class type is: Measurement<double>
Instantiation of
specialisations
Class templates Template

(not
compileable)
Try a different datatype…

Output:
#include <iostream> instantiation
template<typename T> My height is 1.83 m.
class Measurement {
private: Why explicit specialisation?
T value; Specialisation happens at object instantiation
public: (same as template function specialisation), but
T getValue() { return value;
the }object instantiations do not include any Specialisation
void setValue(T val) { value = val;
data. }
So compiler cannot determine class (compileable
}; datatype at instantiation, therefore we must C++ code)
stipulate the datatype.
int main() {
Measurement<double> heightM;
heightM.setValue(1.83);
std::cout << "My height is " << heightM.getValue() << " m.\n";
}
Class templates
What if we want to define a method outside the template class?
#include <iostream>
template<typename T> Define the method Why copy this across?
First declare outside but copy
class Measurement {
the method the class template
private: Because this is an
inside the declaration across
T value; overloaded template
containing class
public: class and there are
T getValue() { return value; } multiple versions of
void setValue(T val) { value = val; } the class.
Define the T RangeMin(T tollerance);
method outside }; So the external
but scope the
method definition
method into its
template<typename T> must be scoped back
containing class
T Measurement<T>::RangeMin(T tollerance) { into the correct
return value - value * tollerance / 100; version of the class
}
Class templates
Example: Eskom supplies 230Vac with 5% tolerance (sometimes!)
So we can use the class to compute the minimum allowable voltage
Exercise: Create a RangeMax method to find the max allowable voltage
int main() {
Measurement<int> VoltV;
VoltV.setValue(230);
std::cout << "Eskom voltage should be " << VoltV.getValue() << " V (nominal).\n";
std::cout << "Eskom voltage should be at least " << VoltV.RangeMin(5) << " V.\n";
}
Output:
Eskom voltage should be 230 V (nominal).

Eskom voltage should be at least 219 V.
Template classes with template
member functions
We have seen template member functions inside of normal
classes
We have seen template classes
Can we have template member functions inside a template

class?
Yes…
member functions
#include <iostream>
class Measurement {
private: We have a template class
T value; …with…
public: a template member declaration
template<typename toll>
Here we have the
toll RangeMin(toll tollerance);
template member definition
};
that is scoped to the
containing template class
template <typename T> Measurement<T>
template <typename toll>
toll Measurement<T>::RangeMin(toll tollerance) {
return value - value * tollerance / 100;
}
member functions
#include <iostream>
class Measurement {
WARNING! This is not a class…
private:
It is a template that represents
T value;
several class overloads!!!
public:
There are many versions of this
class…
template<typename toll>
}; So… the compiler must scope
this function into the correct
class version… so we fully
template <typename T> specify the class instance like
template <typename toll> this… Measurement<T>
}
member functions
#include <iostream>
class Measurement {
private:
T value;
public:
1. class tempate void setValue(T val) { value = val; }
template<typename toll> 3. class name (full)
};
2. method tempate
template <typename T>

template <typename toll>
}
member functions
Output… can you explain what happened here?
int main() {
Measurement<int> VoltV;
VoltV.setValue(230);
std::cout << "Eskom voltage should be " << VoltV.getValue() << " V (nominal).\n";
std::cout << "Eskom voltage should be at least " << VoltV.RangeMin(5.0) << " V.\n";
}
Output:
Eskom voltage should be 230 V (nominal).

Eskom voltage should be at least 218.5 V.
Exercise:
1. Add a RangMax template method
2. Deploy Measurement<double> class specialisation
Aside: Towards “Inclusion Model” of organising
template class code
These code fragments can be organised into separate files…
#include <iostream>
This looks like a class
class MFTdemo2 { header
public:
template<typename T> So… Let us try to
T ModMyVar(T var); separate these into
}; three files like we did
This looks like a class in previous lectures
implementation file with non-template
T MFTdemo2::ModMyVar(T var) { examples
return 3 * var;
}
This looks like a your
main application file
int main(){
MFTdemo2 OBJ2;
}
template class code
#pragma once #include “MFTdemo.h”
class MFTdemo2 { template<typename T>

public: T MFTdemo2::ModMyVar(T var) {
template<typename T> return 3 * var;
T ModMyVar(T var); }
};
Its an OOP oops!!!
Looks fine, compiles fine, but
fails to link and execute…
WHY???
#include <iostream>
#include “MFTdemo.h”
int main(){
MFTdemo2 OBJ2;
}
template class code

EachT> cpp file compiles return
template<typename independently
3 * var; and
apparently successfully… but linking seems to
};
fail. Why?
1>MFTdemo.obj : error LNK2019: unresolved external symbol
"public: double __thiscall MFTdemo::ModMyVar<double>(double)"
#include <iostream>
(??$ModMyVar@N@MFTdemo@@QAENN@Z) referenced in function _main
int main(){
MFTdemo2 OBJ2;
}
template class code
Each cpponce
#pragma file compiles independently and apparently
#include “MFTdemo.h” successfully…
but linking seems to fail. Why?
In order to instantiate
template<typename T> the template return
(early3 * binding),
var; the compiler
T ModMyVar(T
needs var);
two things… }
};
• The template definition (we placed it in MFTdemo.cpp)
• The call to the template function (we placed it in MyProg.cpp)
But these<iostream>
#include are in two files that compile separately. So when
compiling MyProg.cpp, the template definition is missing, and when
compiling
int main(){MFTdemo.cpp the call is missing. The binding is not
clear and the
MFTdemo2 OBJ2;compiler creates a reference for the linker to
std::cout
resolve. << "OBJ2.ModMyVar(3.6)
Unfortunately = " << OBJ2.ModMyVar(3.6)
the linker << "\n"; it.
may fail to resolve
}
#pragma once template class code
class MFTdemo2 {
public: #include “MFTdemo.h”
T ModMyVar(T var); template<typename T>
}; T MFTdemo2::ModMyVar(T var) {
return 3 * var;
template<typename T> }
T MFTdemo2::ModMyVar(T var) {
return 3 * var;
Solution one: Insert all the class code in the class
}
header file and remove the class .cpp file. This
effectively produces one file again before
compilation. So early binding is successful.
#include <iostream>
#include “MFTdemo.h” Unfortunately, we no longer have separate
declaration and definition files for our class.
int main(){ Solution works but it is not comfortable.
MFTdemo2 OBJ2;
}
template class code

};
#include <iostream> Solution two: Include the class declaration and

#include “MFTdemo.h” definition files in MyProg.cpp. This solution also
#include “MFTdemo.cpp” produces one file again. So it like solution one, it
compiles and links
int main(){
MFTdemo2 OBJ2;
}
template class code

};
#include <iostream> Solution two: Easy fix, works well, but we are
#include “MFTdemo.h” now including .cpp files. This breaks traditional
#include “MFTdemo.cpp” practice where only .h files are included. This
leads us to solution three…
int main(){
MFTdemo2 OBJ2;
}
template class code
#pragma once #pragma once
class MFTdemo2 {
public: template<typename T>
template<typename T> T MFTdemo2::ModMyVar(T var) {
T ModMyVar(T var); return 3 * var;
}; }
#include <iostream> Solution Three: Place the class definitions and

#include “MFTdemo.h” declarations in two header files. Then include
#include “MFTdemoDefs.h” both. Easy fix, works well, we are now including
two .h files. There is no .cpp file for the class…
int main(){ similar to solution one, but the class has two files.
MFTdemo2 OBJ2;
}
Aside: Final “Inclusion Model” of organising
template class code
#pragma once #pragma once
class MFTdemo2 {
public: template<typename T>
template<typename T> T MFTdemo2::ModMyVar(T var) {
T ModMyVar(T var); return 3 * var;
}; }
#include <iostream>
#include “MFTdemo.h” Solution Three: best solution for
#include “MFTdemoDefs.h” templated classes!!!
int main(){
MFTdemo2 OBJ2;
}

Lecture 5. Basics Part 4

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Lecture 5. Basics Part 4

Uploaded by

Copyright:

Available Formats

Computer Methods 3

• We look at template instantiation

• We look at simple templated OOP coding...

• We deploy code samples at each step

Somewhere in memory Somewhere else in

&xptr > xptr = &x; &x >

Now we use the reference: int &xref = x;

A single template represents a whole set of functions

instantiation instantiation instantiation

Template • Templates must be converted to specialisations

template <class T> template <class T>

k =GetMax(i,j); n =GetMax(l,m); int main () {

template <class T> template <class T>

Template template <class T, class U> int i,j;

Remember… function templates are just special cases of function

We now look at the basics of templates in the OOP paradigm

More specifically, we will look at:

• Member function templates and

This gets complex very quickly, so we only do the basics.

Assume that we have defined a class with public member functions…

#include <iostream> Output:

class MFTdemo1 { OBJ1.ModMyVar(3) = 9

• Can be done if we have class overloads with the same logic

• Class templates allow us to create a generic class definition,

Measurement<int> heightCM; Measurement<double> heightM;

class Measurement <int> { class Measurement <double> {

Class templates Template

Try a different datatype…

Eskom voltage should be 230 V (nominal).

We have seen template classes

Can we have template member functions inside a template

template <typename T>

Eskom voltage should be 230 V (nominal).

class MFTdemo2 { template<typename T>

class MFTdemo2 { template<typename T>

class MFTdemo2 { template<typename T>

#include <iostream> Solution two: Include the class declaration and

class MFTdemo2 { template<typename T>

#include <iostream> Solution Three: Place the class definitions and

You might also like