模板参数类型

这是《深入实践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;
}