这是《深入实践C++模板编程》第三章“模板参数类型详解”的读书笔记。
模板参数类型
模板参数通常表示类型,表示类型的模板参数称为类型模板参数(type template parameter);此外还有非类型模板参数(non-type template parameter),非类型模板参数包含以下四种类型:
- 整数及枚举类型
- 指针(对象指针或函数指针)
- 引用(对象引用或函数引用)
- 指向类对象成员函数的指针
模板的参数还可以是一个模板,叫做模板模板参数(template template parameter)。这些类型的模板参数都可以同时出现在模板参数列表中。
整数模板参数
非类型模板参数的作用,是为函数模板或类模板预定义一些常量。这些常量的值在编译期已知,所有模板实例中,都有相同的值。例如一个固定长度的数据类
#include <iostream>
#include <stdexcept>
template<typename T, unsigned size>
class array {
T elems[size];
public:
T& operator[] (unsigned i) throw (std::out_of_range) {
if (i >= size) {
throw std::out_of_range("array access out of range.");
}
else return elems[i];
}
};
int main(int argc, char* argv[]) {
array<char, 20> array0;
array<char, 10> array1;
array0[10] = 'b';
try {
array1[10] = 'b';
}
catch (std::out_of_range& e) {
std::cerr << "Access out of range." << std::endl;
}
return 0;
}
函数指针模板参数
函数指针通常用于实现回调。函数指针模板参数也可以用于实现回调,只不过普通函数指针的回调函数可以在运行期确定,函数指针作为模板参数时,要在编译期确定。
#include <iostream>
template<typename T, void (*f) (T &v)>
void foreach(T array[], unsigned size) {
for (unsigned i = 0; i < size; ++i)
f(array[i]);
}
template<typename T>
void inc(T &v) {
++v;
}
template<typename T>
void dec(T &v) {
--v;
}
template<typename T>
void print(T& v) {
std::cout<< ' ' << v;
}
int main(int argc, char* argv[]) {
int array[] = {1, 2, 3, 4, 5, 6, 7, 8};
foreach<int, print<int>>(array, 8);
std::cout << std::endl;
foreach<int, inc<int>>(array, 8);
foreach<int, print<int>>(array, 8);
std::cout << std::endl;
foreach<int, dec<int>>(array, 8);
foreach<int, print<int>>(array, 8);
std::cout << std::endl;
return 0;
}
指针及引用模板参数
指针和引用作为模板参数时,相当于为函数或对象声明一个常量指针或引用。因为模板参数是在编译期确定的,所以只有全局变量/外部变量(extern修饰)/类的静态变量的指针或引用才可以作为模板参数。
#include <iostream>
template<int *p>
struct wrapper {
int get() {
return *p;
}
void set(int v) {
*p = v;
}
};
template<int &p>
struct wrapper2 {
int get() {
return p;
}
void set(int v) {
p = v;
}
};
int main(int argc, char* argv[]) {
int global_variable = 0;
wrapper<&global_variable> gwrapper;
gwrapper.set(1);
std:: cout << gwrapper.get() << std::endl;
wrapper2<global_variable> gwrapper2;
gwrapper2.set(2);
std::cout<< gwrapper2.get() << std::endl;
return 0;
}
成员函数指针模板参数
成员函数指针作为函数模板参数时,和普通函数指针类型,只是声明方法看上去难理解。例如类some_class
有多个函数,参数都为int
,返回值也为int
,那么指向这些成员函数的指针可以声明为
int (some_class:: *mfp)(int);
可以用typedef
定义别名,精简一下
typedef int (some_class:* some_class_mfp)(int);
some_class_mfp mfp;
使用成员函数指针调用函数时,要用到操作符*.
和->
。这两个操作符优先级比较低,通常需要用括号括起来。例如:
some_class a;
std::cout << (a.*mfp)(0) << std::endl;
some_class *p(&a);
std::cout << (p->*mfp)(0) << std::endl;
下面示例为一个some_class
类包含3个成员函数add_by
,sub_by
,mul_by
,分别对成员变量value
进行对应操作。
#include <iostream>
class some_value {
int value;
public:
some_value(int _value): value(_value) {}
int add_by(int op) { return value += op;}
int sub_by(int op) { return value -= op;}
int mul_by(int op) { return value *= op;}
};
int main(int argc, char* argv[]) {
some_value v0(0);
std::cout<< call<&some_value::add_by>(v0, 1) << std::endl;
std::cout<< call<&some_value::sub_by>(v0, 2) << std::endl;
std::cout<< call<&some_value::mul_by>(v0, 3) << std::endl;
return 0;
}
需要注意的是,在取成员函数指针是,取地址符&
不能省略。
模板型模板参数
模板型模板参数只是,模板的参数是另外一个模板。声明形式类似:
template<typename T, template<typename TT0, typename TT1> class A>
struct Foo {A<T, T> bar;};
上面声明中的第二个模板参数A是一个类模板。注意声明中要用到关键字class。只有类模板可以作为模板参数。
在函数指针模板参数的例子中,有
foreach<int, print<int>> (array, 8);
foreach<int, inc<int>> (array, 8);
foreach<int, dec<int>> (array, 8);
上面都将int
重复两遍有点冗余。三个函数print
,inc
,dec
都是函数模板。可以用带参数的模板传入,在foreach
内进行实例化即可。只是需要将三个函数模板修改为类模板。
#include <iostream>
template<template<typename TT> class Func, typename T>
void foreach(T array[], unsigned size) {
Func<T> func;
for (unsigned i = 0; i < size; ++i)
func(array[i]);
}
template<typename T>
struct inc {
void operator() (T &v) const {++v;}
};
template<typename T>
struct dec {
void operator() (T &v) const {--v;}
};
template<typename T>
struct print {
void operator() (T &v) const { std::cout << " " << v;}
};
int main(int argc, char* argv[]) {
int array[] = {1, 2, 3, 4, 5, 6, 7, 8};
foreach<print>(array, 8);
std::cout << std::endl;
foreach<inc>(array, 8);
foreach<print>(array, 8);
std::cout << std::endl;
foreach<dec>(array, 8);
foreach<print>(array, 8);
std::cout << std::endl;
return 0;
}