The relationship between a class template and an individual class is like the relationship between a class and an individual object. An individual class defines how a group of objects can be constructed, while a class template defines how a group of classes can be generated.
template< template-parameter-list >
where template-parameter-list is a comma-separated list of one or more of the following kinds
of template parameters: template<class L, class T> class Key;
This reserves the name as a class template name. All template declarations for a class template must have the same types and number of template arguments. Only one template declaration containing the class definition is allowed.
By using template parameter packs, template declarations for a class template can have fewer or more arguments than the number of parameters specified in the class template.template<class L, class T> class Key { /* ... */};
template<class L> class Vector { /* ... */ };
int main ()
{
class Key <int, Vector<int> > my_key_vector;
// implicitly instantiates template
}
template<typename T> struct list {};
template<typename T>
struct vector
{
operator T() const;
};
int main()
{
// Valid, same as vector<vector<int> > v;
vector<vector<int>> v;
// Valid, treat the >> token as two consecutive > tokens.
// The first > token is treated as the ending delimiter for the
// template_parameter_list, and the second > token is treated as
// the ending delimiter for the static_cast operator.
const vector<int> vi = static_cast<vector<int>>(v);
}
A parenthesized expression is a delimited expression
context. To use a bitwise shift operator inside template-argument-list, use parentheses to enclose the operator. For example:template <int i> class X {};
template <class T> class Y {};
Y<X<(6>>1)>> y; //Valid: 6>>1 uses the right shift operator
template<class T> class Vehicle
{
public:
Vehicle() { /* ... */ } // constructor
~Vehicle() {}; // destructor
T kind[16];
T* drive();
static void roadmap();
// ...
};
Vehicle<char> bicycle; // instantiates the template
the constructor, the constructed object, and the member function drive() can be accessed with any of the following (assuming the standard header file string.h is included in the program file):
constructor |
|
object bicycle |
|
function drive() | char* n = bicycle.drive(); |
function roadmap() | Vehicle<char>::roadmap(); |