模板参数并不局限于类定义的类型,可以使用编译器内置类型
参数在编译期间变成模板的特定常量。我们甚至可以对这些参数使用默认值实例化设置Array类的长度,并且还可以提供默认值
//: C16:Array3.cpp
// From Thinking in C++, 2nd Edition
// Available at http://www.BruceEckel.com
// (c) Bruce Eckel 2000
// Copyright notice in Copyright.txt
// 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;
getchar();
} ///:~
Array是被检查的对象数组,并且防止下标越界。
类Holder很像Array,只是它有一个指向Array的指针,而不是指向类型Array
的嵌入对象。
该指针在构造函数中不被初始化,而是推迟到第一次访问时
这称为懒惰初始化。
如果创造大量的对象,但不访问每一个对象,为了节省存储,可以用懒惰
初始化技术
输出
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19