|
 |
|
| |
Constants in templates
Template arguments are not restricted to
class types; you can also use built-in types. The values of these arguments then
become compile-time constants for that particular instantiation of the template.
You can even use default values for these arguments. The following example
allows you to set the size of the Array class during instantiation, but
also provides a default value:
//: C16:Array3.cpp
// Built-in types as template arguments
#include "../require.h"
#include <iostream>
using namespace std;
template<class T, int size = 100>
class Array {
T array[size];
public:
T& operator[](int index) {
require(index >= 0 && index < size,
"Index out of range");
return array[index];
}
int length() const { return size; }
};
class Number {
float f;
public:
Number(float ff = 0.0f) : f(ff) {}
Number& operator=(const Number& n) {
f = n.f;
return *this;
}
operator float() const { return f; }
friend ostream&
operator<<(ostream& os, const Number& x) {
return os << x.f;
}
};
template<class T, int size = 20>
class Holder {
Array<T, size>* np;
public:
Holder() : np(0) {}
T& operator[](int i) {
require(0 <= i && i < size);
if(!np) np = new Array<T, size>;
return np->operator[](i);
}
int length() const { return size; }
~Holder() { delete np; }
};
int main() {
Holder<Number> h;
for(int i = 0; i < 20; i++)
h[i] = i;
for(int j = 0; j < 20; j++)
cout << h[j] << endl;
} ///:~
As before, Array is a checked
array of objects and prevents you from indexing out of bounds. The class
Holder is much like Array except that it has a pointer to an
Array instead of an embedded object of type Array. This pointer is
not initialized in the constructor; the initialization is delayed until the
first access. This is called
lazy initialization; you
might use a technique like this if you are creating a lot of objects, but not
accessing them all, and want to save storage.
You’ll notice that the size
value in both templates is never stored internally in the class, but it is used
as if it were a data member inside the member
functions.
|
|
|
