Advanced Templates
Templates with Multiple Type Parameters
A class template may have more than one type parameter.
The template below defines a class that encapsulates pairs
of objects -- the first is the key, the second is the data.
<![CDATA[
#include <iostream>
#include <string>
using namespace std;
// defines Pair as a template with two
// template parameters
template < class Key, class Data >
class Pair
{
public:
// default constructor
Pair( );
// destructor
~Pair( );
// copy constructor
Pair( const Pair<Key, Data>& pair);
// equality operator
bool operator== (const Pair<Key, Data>& rhs) const;
private:
Key m_key;
Data m_data;
};
// Pair's equality operator
template <class K, class D>
bool Pair<K, D>::operator== (const Pair<K,D>& rhs) const
{
return m_key == rhs.m_key && m_data == rhs.m_data;
}
int main ( )
{
string bob = "bob";
string mary = "mary";
// use pair to associate a string and its length
Pair< int, string > boy (bob.length(), bob);
Pair< int, string > girl (mary.length(), mary);
// make a new pair using copy constructor
Pair<int, string> dad = boy;
// check for equality
if (bob == girl)
cout << "They match\n";
// use Pair for names and Employee object
Employee john, mark;
Pair< string, Employee> boss ("john", john);
Pair< string, Employee> worker( "mark", mark);
if (boss == worker)
cout << "A real small company\n";
return 0;
}
]]>
Templates can have Nontype Parameters
Not all of the parameters for a template need be class type
parameters. For instance, we could have written the SmartArray
template to include the size as a nontype template parameter
as shown below. This technique avoids the necessity of using
dynamically allocated memory for the SmartArray class.
<![CDATA[
template <class T, int size>
class SmartArray
{
public:
SmartArray ( );
// other members
private:
int m_size;
T m_data[ size ];
};
template< class T, int size>
SmartArray<T, size>::SmartArray( )
{
m_size = size;
}
]]>
Templates as Parameters
When we wish to pass a template class to a function, that function becomes
a function template. Here's the definition for a function that sorts
the elements of a smart arrary. We want to use it for all types of
smart arrays, so we pass the smart array template as the parameter.
<![CDATA[
template <class T>
void Sort ( SmartArray<T>& theArray)
{
// code here
}
]]>
Templates and Friends
We can make functions friends of templates too. For example, if we want to output
SmartArrays using operator<<, we define the function as a template
as above
<![CDATA[
template <class T>
ostream& operator<< (ostream& out, const SmartArray<T>& theArray)
{
// code here
}
]]>
In the SmartArray class definition we declare operator<< to be our friend in the usual way, but we must tell the compiler that operator<<
is a template function. One easy way to do this by including "<>" after the
name of the function.
<![CDATA[
template <class T>
class SmartArray
{
friend ostream& operator<< <> (ostream& out, const SmartArray<T>& theArray);
// the rest of the SmartArray class definition
};
]]>
There is one other key component to completing your implementation of a
templated friend in your application, in order to allow the compiler to
understand where the operator belongs and which class it belongs to. We use a
technique called "forward declaring" in order to notify the compiler of each
of these components. Essentially "forward declaring" is prototyping everything
that you will be declaring:
<![CDATA[
template <class T> class FooClass; // forward-declaring class
template <class T> ostream& operator<< (ostream& out, const FooClass &foo); // forward-declaring insertion stream
template <class T>
class FooClass
{
public:
friend ostream& operator<< <> (ostream& out, const FooClass &foo);
private:
};
template <class T>
ostream& operator<< (ostream& out, const FooClass &foo)
{
// implementation
}
]]>
Last Modified: Monday, 28-Aug-2006 10:16:05 EDT