2014-02-18 23:42:28 +08:00
2013-04-29 12:13:12 +08:00
# C++ Template 进阶指南
## 0. 前言
###0.1 C++另类简介：比你用的复杂，但比你想的简单
C++似乎从他为世人所知的那天开始便成为天然的话题性编程语言。在它在周围有着形形色色的赞美与贬低之词。当我在微博上透露欲写此文的意愿时，也收到了很多褒贬不一的评论。作为一门语言，能拥有这么多使用并恨着它、使用并畏惧它的用户，也算是语言丛林里的奇观了。
C++之所以变成一门层次丰富、结构多变、语法繁冗的语言， ， （ ） ，
模板作为C++中最有特色的语言特性， ， ， ， （ ） ，
但是实际上C++模板远没有想象的那么复杂。我们只需要换一个视角： ， ， ， ， ， ， ， ， ，
2014-02-18 23:42:28 +08:00
简单回顾一下模板的历史。87年的时候， （ ） ， ， ， ，
2013-04-29 12:13:12 +08:00
2014-02-14 13:18:56 +08:00
此时不少人以为STL已经是C++模板的集大成之作， ， ， ， ，
2013-04-29 12:13:12 +08:00
2014-02-18 23:42:28 +08:00
2002年出版的另一本书《C++ Templates》， ， ， ，
2013-04-29 12:13:12 +08:00
本文的写作初衷，就是通过“编程语言”的视角，介绍一个简单、清晰的“模板语言”。我会尽可能的将模板的诸多要素连串起来，用一些简单的例子帮助读者学习这门“语言”，让读者在编写、阅读模板代码的时候，能像 `if(exp) { dosomething(); }` 一样的信手拈来，让“模板元编程”技术成为读者牢固掌握、可举一反三的有用技能。
###0.2 适宜读者群
因为本文并不是用于C++入门，例子中也多少会牵涉一些其它知识，因此如果读者能够具备以下条件，会读起来更加轻松：
* 熟悉C++的基本语法；
* 使用过STL；
* 熟悉一些常用的算法，以及递归等程序设计方法。
此外， ， ；
诚如上节所述， ， ， ， ， ； ， ， ， ； （ ） ，
###0.3 版权
本文是随写随即同步到Github上， ， ， ，
全文所有为我所撰写的部分，作者均保留所有版权。如果有需要转帖或引用，还请注明出处并告知于我。
2014-02-19 03:13:06 +08:00
###0.4 意见、建议、喷、补遗、写作计划
2014-02-12 15:53:47 +08:00
2014-02-28 04:38:54 +08:00
* 需增加：
* 模板的使用动机。
* 建议：
* 比较模板和函数的差异性
* 蓝色：
2014-02-12 15:53:47 +08:00
2013-04-29 12:13:12 +08:00
## 1. Template的基本语法
###1.1 Template Class基本语法
####1.1.1 Template Class的与成员变量定义
我们来回顾一下最基本的Template Class声明和定义形式：
Template Class声明：
```C++
template < typename T > class ClassA;
```
Template Class定义：
```C++
template < typename T > class ClassA
{
T member;
};
```
`template` 是C++关键字， ， < >`中。在上文的例子中， `typename T` 便是模板参数。回顾一下与之相似的函数参数的声明形式：
``` C++
void foo(int a);
```
2014-02-13 15:29:18 +08:00
`T` 则可以类比为函数形参`a`，这里的“模板形参”`T`，也同函数形参一样取成任何你想要的名字；`typename`则类似于例子中函数参数类型`int`，它表示模板参数中的`T`将匹配一个类型。除了 `typename` 之外，我们再后面还要讲到，整型也可以作为模板的参数。
2013-04-29 12:13:12 +08:00
在定义完模板参数之后，便可以定义你所需要的类。不过在定义类的时候，除了一般类可以使用的类型外，你还可以使用在模板参数中使用的类型 `T` 。可以说，这个 `T` 是模板的精髓， ，
例如我们用`ClassA< int > `来实例化模板类ClassA， < int > `可以等同于以下的定义：
``` C++
// 注意：
typedef class {
int member;
} ClassA< int > ;
```
可以看出， ， ， ， （ ） ， ，
####1.1.2 模板的使用
对于C++来说，类型最重要的作用之一就是用它去产生一个变量。例如我们定义了一个动态数组（列表）的模板类`vector`， ， ：
```C++
template < typename T >
class vector
{
public:
void push_back(T const&);
void clear();
private:
T* elements;
};
```
此时我们的程序需要一个整型和一个浮点型的列表，那么便可以通过以下代码获得两个变量：
```C++
vector< int > intArray;
vector< float > floatArray;
```
此时我们就可以执行以下的操作，获得我们想要的结果：
```C++
intArray.push_back(5);
floatArray.push_back(3.0f);
```
变量定义的过程可以分成两步来看：第一步，`vector< int > `将`int`绑定到模板类`vector`上，获得了一个“普通的类`vector< int > `”； < int > ”定义了一个变量。
与“普通的类”不同，模板类是不能直接用来定义变量的。例如
```C++
vector unknownVector; // 错误示例
```
这样就是错误的。我们把通过类型绑定将模板类变成“普通的类”的过程， （ ） ：
```
模板名 < 模板实参1 [ ， 模板实参2 ， . . . ] >
```
看几个例子：
```C++
vector< int >
ClassA< double >
template < typename T0 , typename T1 > class ClassB
{
// Class body ...
};
ClassB< int , float >
```
当然，在实例化过程中，被绑定到模板参数上的类型（即模板实参）需要与模板形参正确匹配。
就如同函数一样，如果没有提供足够并匹配的参数，模板便不能正确的实例化。
####1.1.3 模板类的成员函数定义
由于C++11正式废弃“模板导出”这一特性， ， ，
例如：
``` C++
template < typename T >
class vector
{
public:
void clear()
{
// Function body
}
private:
T* elements;
};
```
当然，我们也可以将`vector< T > ::clear`的定义部分放在类型之外，只不过这个时候的语法就显得蹩脚许多：
```C++
template < typename T >
class vector
{
public:
void clear(); // 注意这里只有声明
private:
T* elements;
};
template < typename T >
void vector< T > ::clear() // 函数的实现放在这里
{
// Function body
}
```
函数的实现部分看起来略微拗口。我第一次学到的时候，觉得
``` C++
void vector::clear()
{
// Function body
}
```
这样不就行了吗？但是简单想就会知道，`clear`里面是找不到泛型类型`T`的符号的。
因此，在成员函数实现的时候，必须要提供模板参数。此外，为什么类型名不是`vector`而是`vector< T > `呢？
如果你了解过模板的偏特化与特化的语法， ， < T > 在语法上类似于特化/偏特化。实际上，这里的函数定义也确实是成员函数的偏特化。特化和偏特化的概念，本文会在第二部分详细介绍。
2014-02-13 15:29:18 +08:00
综上，正确的成员函数实现如下所示：
2013-04-29 12:13:12 +08:00
``` C++
template < typename T > // 模板参数
void vector< T > /*看起来像偏特化*/ ::clear() // 函数的实现放在这里
{
// Function body
}
```
###1.2 Template Function的基本语法
####1.2.1 Template Function的声明和定义
模板函数的语法与模板类基本相同，也是以关键字`template`和模板参数列表作为声明与定义的开始。模板参数列表中的类型，可以出现在参数、返回值以及函数体中。比方说下面几个例子
```C++
template < typename T > void foo(T const& v);
template < typename T > T foo();
template < typename T , typename U > U foo(T const&);
template < typename T > void foo()
{
T var;
// ...
}
```
2013-06-19 00:51:54 +08:00
无论是函数模板还是类模板，在实际代码中看起来都是“千变万化”的。这些“变化”，主要是因为类型被当做了参数，导致代码中可以变化的部分更多了。
归根结底，模板无外乎两点：
1. 函数或者类里面，有一些类型我们希望它能变化一下，我们用标识符来代替它，这就是“模板参数”；
2. 在需要这些类型的地方，写上相对应的标识符（“模板参数”）。
当然，这里的“可变”实际上在代码编译好后就固定下来了，可以称之为编译期的可变性。
这里多啰嗦一点，主要也是想告诉大家，模板其实是个很简单的东西。
下面这个例子，或许可以帮助大家解决以下两个问题：
1. 什么样的需求会使用模板来解决？
2. 怎样把脑海中的“泛型”变成真正“泛型”的代码？
```
举个例子： ‘ ’
```
在我遇到的朋友中，即便如此对他解释了模板，即便他了解了模板，也仍然会对模板产生畏难情绪。毕竟从形式上来说，模板类和模板函数都要较非模板的版本更加复杂，阅读代码所需要理解的内容也有所增多。
2013-04-29 12:13:12 +08:00
2013-06-19 00:51:54 +08:00
如何才能克服这一问题，最终视模板如平坦代码呢？
答案只有一个：无他，唯手熟尔。
在学习模板的时候，要反复做以下的思考和练习：
1. 提出问题：我的需求能不能用模板来解决？
2. 怎么解决？
3. 把解决方案用代码写出来。
4. 如果失败了，找到原因。是知识有盲点（例如不知道怎么将 `T&` 转化成 `T` ），还是不可行（比如试图利用浮点常量特化模板类，但实际上这样做是不可行的）？
通过重复以上的练习，应该可以对模板的语法和含义都有所掌握。如果提出问题本身有困难，或许下面这个经典案例可以作为你思考的开始：
1. 写一个泛型的数据结构：例如，线性表，数组，链表，二叉树；
2. 写一个可以在不同数据结构、不同的元素类型上工作的泛型函数，例如求和；
当然和“设计模式”一样， ， ： （ ） （ ） （ ， ）
####1.2.2 模板函数的使用
2013-04-29 12:13:12 +08:00
2014-02-12 15:40:23 +08:00
我们先来看一个简单的函数模板，两个数相加：
``` C++
template < typename T > T Add(T a, T b)
{
return a + b;
}
```
函数模板的调用格式是：
``` C++
函数模板名 < 模板参数列表 > ( 参数 )
```
例如，我们想对两个 `int` 求和，那么套用类的模板实例化方法，我们可以这么写：
``` C++
int a = 5;
int b = 3;
int result = Add< int > (a, b);
```
这时我们等于拥有了一个新函数：
``` C++
int Add< int > (int a, int b) { return a + b; }
```
2014-02-12 15:53:47 +08:00
这时在另外一个偏远的程序角落，你也需要求和。而此时你的参数类型是 `float` ，于是你写下：
2014-02-12 15:40:23 +08:00
``` C++
Add< float > (a, b);
```
2014-02-12 15:53:47 +08:00
一切看起来都很完美。但如果你具备程序员的最佳美德——懒惰——的话，你肯定会这样想，我在调用 `Add<int>(a, b)` 的时候， `a` 和 `b` 匹配的都是那个 `T` 。编译器就应该知道那个 `T` 实际上是 `int` 呀？为什么还要我多此一举写 `Add<int>` 呢？
2014-02-12 15:40:23 +08:00
唔，我想说的是，编译器的作者也是这么想的。所以实际上你在编译器里面写下以下片段：
``` C++
int a = 5;
int b = 3;
int result = Add(a, b);
```
2014-02-12 15:53:47 +08:00
编译器会心领神会的将 `Add` 变成 `Add<int>` 。但是编译器不能面对模棱两可的答案。比如你这么写的话呢？
2014-02-12 15:40:23 +08:00
``` C++
int a = 5;
char b = 3;
int result = Add(a, b);
```
第一个参数 `a` 告诉编译器，这个 `T` 是 `int` 。编译器点点头说，好。但是第二个参数 `b` 不高兴了，告诉编译器说，你这个 `T` ，其实是 `char` 。
两个参数各自指导 `T` 的类型， ， ：
```
error C2782: 'T _1_2_2::Add(T,T)' : template parameter 'T' is ambiguous
```
2014-02-12 15:53:47 +08:00
好吧，"ambigous"，这个提示再明确不过了。
2014-02-12 15:40:23 +08:00
不过，只要你别逼得编译器精神分裂的话，编译器其实是非常聪明的，它可以从很多的蛛丝马迹中，猜测到你真正的意图，有如下面的例子：
2014-02-12 15:44:16 +08:00
``` C++
2014-02-12 15:40:23 +08:00
template < typename T > class A {};
template < typename T > T foo( A< T > v );
A< int > v;
2014-02-12 15:53:47 +08:00
foo(v); // 它能准确的猜到 T 是 int.
2014-02-12 15:40:23 +08:00
```
咦， ， `T` 匹配的是 `int` 。编译器是怎么完成这一“魔法”的， ，
下面轮到你的练习时间了。你试着写了很多的例子，但是其中一个你还是犯了疑惑：
``` C++
float data[1024];
template < typename T > T GetValue(int i)
{
return static_cast< T > (data[i]);
}
2014-02-12 15:53:47 +08:00
float a = GetValue(0); // 出错了！
int b = GetValue(1); // 也出错了！
2014-02-12 15:40:23 +08:00
```
2014-02-13 15:29:18 +08:00
为什么会出错呢？你仔细想了想，原来编译器是没办法去根据返回值推断类型的。函数调用的时候，返回值被谁接受还不知道呢。如下修改后，就一切正常了：
2014-02-12 15:40:23 +08:00
``` C++
float a = GetValue< float > (0);
int b = GetValue< int > (1);
```
嗯， ？ ， ：
2014-02-13 15:29:18 +08:00
你要写一个模板函数叫 `c_style_cast` ， ， ， `static_cast` 这样的内置转换有同样的写法。于是你写了一个use case。
2014-02-12 15:40:23 +08:00
2014-02-12 15:44:16 +08:00
``` C++
2014-02-12 15:40:23 +08:00
DstT dest = c_style_cast< DstT > (src);
```
根据调用形式你知道了，有 `DstT` 和 `SrcT` 两个模板参数。参数只有一个， `src` ，所以函数的形参当然是这么写了： `(SrcT src)` 。实现也很简单， `(DstT)v` 。
2014-02-13 15:29:18 +08:00
2014-02-12 15:40:23 +08:00
我们把手上得到的信息来拼一拼，就可以编写自己的函数模板了：
2014-02-12 15:44:16 +08:00
``` C++
2014-02-12 15:40:23 +08:00
template < typename SrcT , typename DstT > DstT c_style_cast(SrcT v)
{
return (DstT)(v);
}
int v = 0;
float i = c_style_cast< float > (v);
```
嗯， ！ ！ ！
2014-02-12 15:44:16 +08:00
``` C++
2014-02-12 15:40:23 +08:00
error C2783: 'DstT _1_2_2::c_style_cast(SrcT)' : could not deduce template argument for 'DstT'
```
2014-02-13 15:29:18 +08:00
然后你仔细的比较了一下，然后发现 … 模板参数有两个，而参数里面能得到的只有 `SrcT` 一个。结合出错信息看来关键在那个 `DstT` 上。这个时候，你死马当活马医，把模板参数写完整了：
2014-02-12 15:40:23 +08:00
2014-02-12 15:44:16 +08:00
``` C++
2014-02-12 15:40:23 +08:00
float i = c_style_cast< float , int > (v);
```
嗯，
当然是可以的。只不过在部分推导、部分指定的情况下，编译器对模版参数的顺序是有限制的：先写需要指定的模板参数，再把能推导出来的模板参数放在后面。
2014-02-13 15:29:18 +08:00
在这个例子中，能推导出来的是 `SrcT` ，需要指定的是 `DstT` 。把函数模板写成下面这样就可以了：
2014-02-12 15:40:23 +08:00
2014-02-12 15:44:16 +08:00
``` C++
2014-02-12 15:40:23 +08:00
template < typename DstT , typename SrcT > DstT c_style_cast(SrcT v) // 模版参数 DstT 需要人肉指定，放前面。
{
return (DstT)(v);
}
int v = 0;
2014-02-12 15:53:47 +08:00
float i = c_style_cast< float > (v); // 形象地说， ，
2014-02-12 15:40:23 +08:00
```
2013-04-29 12:13:12 +08:00
###1.3 整型也可是Template参数
2014-02-13 15:29:18 +08:00
模板参数除了类型外（ ） ， （ ） ， ， ：
``` C++
template < typename T > class TemplateWithType;
template < int V > class TemplateWithValue;
```
我想这个时候你也更能理解 `typename` 的意思了：它相当于是模板参数的“类型”，告诉你 `T` 是一个 `typename` 。
按照C++ Template最初的想法， ？ ， ？ ， ， ， ：
``` C++
template < typename T , int Size > struct Array
{
T data[Size];
};
Array< int , 16 > arr;
```
便相当于下面这段代码：
``` C++
class IntArrayWithSize16
{
int data[16]; // int 替换了 T, 16 替换了 Size
};
IntArrayWithSize16 arr;
```
其中有一点要注意的是，因为模板的匹配是在编译的时候完成的，所以实例化模板的时候所使用的参数，也必须要在编译期就能确定。例如以下的例子编译器就会报错：
``` C++
template < int i > class A {};
void foo()
{
int x = 3;
A< 5 > a; // 正确！
A< x > b; // error C2971: '_1_3::A' : template parameter 'i' : 'x' : a local variable cannot be used as a non-type argument
}
```
因为x不是一个编译期常量， `A<x>` 就会告诉你， ，
2014-02-13 15:44:12 +08:00
嗯，这里我们再来写几个相对复杂的例子：
2014-02-13 15:29:18 +08:00
``` C++
template < int i > class A
{
public:
void foo(int)
{
}
};
template < uint8_t a , typename b , void * c > class B {};
template < bool , void ( * a ) ( ) > class C {};
template < void ( A < 3 > ::*a)(int)> class D {};
template < int i > int Add(int a) // 当然也能用于函数模板
{
return a + i;
}
void foo()
{
A< 5 > a;
B<
2014-02-13 15:44:12 +08:00
7, A< 5 > , nullptr
2014-02-13 15:29:18 +08:00
> b; // 模板参数可以是一个无符号八位整数，可以是模板生成的类；可以是一个指针。
C< false , & foo > c; // 模板参数可以是一个bool类型的常量，
D< & A< 3 > ::foo> d; // 丧心病狂啊！它还能是一个成员函数指针！
int x = Add< 3 > (5); // x == 8。因为整型模板参数无法从函数参数获得，
}
template < float a > class E {}; // ERROR: 别闹！早说过只能是整数类型的啦！
```
2014-02-13 15:44:12 +08:00
当然， ， ， ，
2014-02-13 15:29:18 +08:00
###1.4 模板形式与功能是统一的
2014-02-13 15:44:12 +08:00
2014-02-13 15:29:18 +08:00
第一章走马观花的带着大家复习了一下C++ Template的基本语法形式， `typename` 在内，类/函数模板写法中各个语法元素的含义。形式是功能的外在体现，介绍它们也是为了让大家能理解到，模板之所以写成这种形式是有必要的，而不是语言的垃圾成分。
从下一章开始，我们便进入了更加复杂和丰富的世界：讨论模板的匹配规则。其中有令人望而生畏的特化与偏特化。但是，请相信我们在序言中所提到的：将模板作为一门语言来看待，它会变得有趣而简单。
2014-02-14 14:13:50 +08:00
## 2. 模板元编程基础
###2.1 编程，元编程，模板元编程
2014-02-28 06:00:11 +08:00
技术的学习是一个登山的过程。第一章是最为平坦的山脚道路。而从这一章开始，则是正式的爬坡。无论是我写作还是你阅读，都需要付出比第一章更多的代价。那么问题就是，付出更多的精力学习模板是否值得？
这个问题很功利，
一个高（ ） （ ） （ ） ， ， （ ） （ ） ， ，
程序最根本的目的是什么？复现真实世界或人所构想的规律，减少重复工作的成本，或通过提升规模完成人所不能及之事。但是世间之事万千，有限的程序如何重现复杂的世界呢？
答案是“抽象”。论及具体手段，无外乎“求同”与“存异”：概括一般规律，处理特殊情况。这也是软件工程所追求的目标。一般规律概括的越好，我们所付出的劳动也就越少。
同样的， ， ：
```
如何撰写更高级的C++程式？
如何应付即使在很干净的设计中仍然像雪崩一样的不相干细节？
如何构建可复用组件，使得每次在不同程式中应用组件时无需大动干戈？
```
我们以数据结构举例。在程序里，你需要一些堆栈。这个堆栈的元素可能是整数、浮点或者别的什么类型。一份整型堆栈的代码可能是：
``` C++
class StackInt
{
public:
void push(Int v);
Int pop();
Int Find(Int x)
{
for(Int i = 1; i < = size; )
{
if(data[i] == x) { return i; }
}
}
// ... 其他代码 ...
};
```
如果你要支持浮点了，那么你只能将代码再次拷贝出来，并作如下修改：
``` C++
class StackFloat
{
public:
void push(Float v);
Float pop();
Int Find(Float x)
{
for(Int i = 1; i < = size; )
{
if(data[i] == x) { return i; }
}
}
// ... 其他代码 ...
};
```
当然也许你觉得这样做能充分体会代码行数增长的成就感。但是有一天，你突然发现：呀，`Find` 函数实现有问题了。怎么办？这个时候也许你只有两份这样的代码，那好说，一一去修正就好了。如果你有十个呢？二十个？五十个？
时间一长，你就厌倦了这样的生活。你觉得每个堆栈都差不多，但是又有点不一样。为了这一点点不一样，你付出了太多的时间。吃饭的时间，泡妞的时间，睡觉的时间，看岛国小电影顺便练习小臂力量的时间。
于是便诞生了新的技术，来消解我们的烦恼。
这个技术的名字，并不叫“模板”，而是叫“元编程”。
2014-03-01 16:06:21 +08:00
元（ ） ， （ ） ， ， ， ， ， ，
回到我们的堆栈的例子。真正执行功能的， ， ， ， ？ ， ， ，
我们的目的， ，
宏的例子姑且不论，我们来看一看模板：
``` C++
template < typename T >
class Stack
{
public:
void push(T v);
T pop();
Int Find(T x)
{
for(Int i = 0; i < = size; ++i)
{
if(data[i] == x) { return i; }
}
}
// ... 其他代码 ...
};
typedef Stack< int > StackInt;
typedef Stack< float > StackFloat;
```
通过模板，我们可以将形形色色的堆栈代码分为两个部分，一个部分是不变的接口，以及近乎相同的实现；另外一部分是元素的类型，它们是需要变化的。因此同函数类似，需要变化的部分，由模板参数来反应；不变的部分，则是模板内的代码。可以看到，使用模板的代码，要比不使用模板的代码简洁许多。
如果元编程中所有的变化的量（或者说元编程的参数），都是类型，那么这样的编程，我们有个特定的称呼，叫“泛型”。
但是你会问，模板的发明，仅仅是为了做和宏几乎一样的替换工作吗？可以说是，也可以说不是。一方面，很多时候模板就是为了替换类型，这个时候作用上其实和宏没什么区别。只是宏是基于文本的替换，被替换的文本本身没有任何语义。只有替换完成，编译器才能进行接下来的处理。而模板会在分析模板时以及实例化模板时时候都会进行检查，而且源代码中也能与调试符号一一对应，所以无论是编译时还是运行时，排错都相对简单。
但是模板也和宏有很大的不同， ， ， ， ：
```
Int8,16: N/A
Int32 : VInt32Mul(int32 * 4, int32 * 4)
Int64 : VInt64Mul(int64 * 2, int64 * 2)
Float : VInt64Mul(float * 2, float * 2)
```
所以对于Int8和Int16， ， ， ：
``` C++
for(v4a, v4b : vectorsA, vectorsB)
{
if type is Int8, Int16
VInt32Mul( ConvertToInt32(v4a), ConvertToInt32(v4b) )
elif type is Int32
VInt32Mul( v4a, v4b )
elif type is Float
...
}
```
2014-03-03 16:52:36 +08:00
这里的问题就在于，如何根据 `type` 分别提供我们需要的实现？这里有两个难点。首先， `if(type == xxx) {}` 是不存在于C++中的。第二，即便存在根据 `type` 的分配方法， ， ，
2014-03-01 16:06:21 +08:00
嗯，聪明你果然想到了，重载也可以解决这个问题。
``` C++
GenericMul(int8 * 4, int8 * 4);
GenericMul(int16 * 4, int16 * 4);
GenericMul(int32 * 4, int32 * 4);
GenericMul(int64 * 4, int64 * 4);
// 其它 Generic Mul ...
for(v4a, v4b : vectorsA, vectorsB)
{
GenericMul(v4a, v4b);
}
```
这样不就可以了吗？
唔，你赢了，是这样没错。但是问题是，我这个平台是你可没见过，它叫 `Deep Thought` ， `int8` ，还有更奇怪的 `int9` , `int11` ，以及可以代表世间万物的 `int42` 。你总不能为之提供所有的重载吧？这简直就像你枚举了所有程序的输入，并为之提供了对应的输出一样。
好吧，我承认这个例子还是太牵强了。不过相信我，在你阅读完第二章和第三章之后，你会将这些特性自如地运用到你的程序之中。你的程序将会变成体现模板“可运算”威力的最好例子。
2014-02-14 14:13:50 +08:00
###2.2 模板世界的If-Then-Else：
2014-03-03 16:52:36 +08:00
####2.2.1 根据类型执行代码
2014-03-03 16:57:28 +08:00
前一节的示例提出了一个要求： ， ， ， ， ， ， ，
2014-03-03 16:52:36 +08:00
``` C
struct Variant
{
union
{
int x;
float y;
} data;
uint32 typeId;
};
Variant addFloatOrMulInt(Variant const* a, Variant const* b)
{
Variant ret;
assert(a->typeId == b->typeId);
if (a->typeId == TYPE_INT)
{
ret.x = a->x * b->x;
}
else
{
ret.y = a->y + b->y;
}
return ret;
}
```
更常见的是 `void*` :
``` C++
#define BIN_OP(type, a, op, b, result) (*(type const *)(result)) = (*(type const *)(a)) op (*(type const*)(b))
void doDiv(void* out, void const* data0, void const* data1, DATA_TYPE type)
{
if(type == TYPE_INT)
{
BIN_OP(int, data0, *, data1, out);
}
else
{
BIN_OP(float, data0, +, data1, out);
}
}
```
2014-03-04 14:57:28 +08:00
在C++中比如在 `Boost.Any` 的实现中，运用了 `typeid` 来查询类型信息。和 `typeid` 同属于RTTI机制的 `dynamic_cast` ，也经常会用来做类型判别的工作。我想你应该写过类似于下面的代码：
2014-03-03 16:52:36 +08:00
``` C++
IAnimal* animal = GetAnimalFromSystem();
IDog* maybeDog = dynamic_cast< IDog * > (animal);
if(maybeDog)
{
maybeDog->Wangwang();
}
ICat* maybeCat = dynamic_cast< ICat * > (animal);
if(maybeCat)
{
maybeCat->Moemoe();
}
```
当然，在实际的工作中，我们建议把需要 `dynamic_cast` 后执行的代码，尽量变成虚函数。不过这个已经是另外一个问题了。我们看到，不管是哪种方法都很难避免 `if` 的存在。而且因为输入数据的类型是模糊的，经常需要强制地、没有任何检查的转换成某个类型，因此很容易出错。
2014-03-04 14:57:28 +08:00
但是模板与这些方法最大的区别并不在这里。模板无论其参数或者是类型，它都是一个编译期分派的办法。编译期就能确定的东西既可以做类型检查，编译器也能进行优化，砍掉任何不必要的代码执行路径。例如在上例中，
``` C++
template < typename T > T addFloatOrMulInt(T a, T b);
// 迷之代码1：
// 迷之代码2：
```
如果你运用了模板来实现，那么当传入两个不同类型的变量，或者不是 `int` 和 `float` 变量，编译器就会提示错误。但是如果使用了我们前述的 `Variant` 来实现，编译器可就管不了那么多了。但是，成也编译期，败也编译期。最严重的“缺点”，就是你没办法根据用户输入或者别的什么在运行期间可能发生变化的量来决定它产生、或执行什么代码。比如下面的代码段，它是不成立的。
``` C++
template < int i , int j >
int foo() { return i + j; }
int main()
{
cin >> x >> y;
return foo< x , y > ();
}
```
这点限制也粉碎了妄图用模板来包办工厂（ ） （ ， ， ； ，
所以说，从能力上来看，模板能做的事情都是编译期完成的。编译期完成的意思就是，当你编译一个程序的时候，所有的量就都已经确定了。比如下面的这个例子：
``` C++
int a = 3, b = 5;
Variant aVar, bVar;
aVar.setInt(a); // 我们新加上的方法，怎么实现的无所谓，大家明白意思就行了。
bVar.setInt(b);
Variant result = addFloatOrMulInt(aVar, bVar);
```
除非世界末日，否则这个例子里不管你怎么蹦跶，单看代码我们就能知道， `aVar` 和 `bVar` 都一定会是整数。所以如果有合适的机制，编译器就能知道此处的 `addFloatOrMulInt` 中只需要执行 `Int` 路径上的代码，而且编译器在此处也能单独为 `Int` 路径生成代码，从而去掉那个不必要的 `if` 。
在模板代码中， （ ） ，
####2.2.2模板原型与偏特化
2014-03-03 16:52:36 +08:00
2014-02-14 14:13:50 +08:00
###2.3 函数模板的重载、参数匹配、特化与部分特化
###2.4 技巧单元：模板与继承
2013-04-29 12:13:12 +08:00
## 3 拿起特化的武器，去写程序吧！
###3.1 利用模板特化规则实现If-Then-Else与Switch-Case
###3.2 特化可以有多个选择：替换失败并不是一个错误，只是一种可能
###3.3 技巧单元： （ ）
## 4 用模板写程序吧！骚年！
###4.1 模板上的递归
###4.2 将循环变成递归，将分支变成递归，将一切变成递归
###4.3 实战单元：
###4.4 技巧单元：
###4.5 实战单元：撰写你自己的元编程“函数”库
###4.6 实战单元：
## 5 关于模板，你还需要知道的其它常识
###5.1 类中类：灵活的模板定义
###5.2 Template-Template Class
###5.3 技巧单元：高阶函数——从函数到函数的组合
###5.4 实战单元：
###5.5 像看堆栈一样的看出错信息
###5.6 模板的症结：易于实现，难于完美
alexandrescu 关于 min max 的讨论：
## 6 C++11的新特性
###6.1 变参模板
###6.2 Lambda与模板程序
2013-04-29 12:14:55 +08:00
## 7 模板的威力：
###7.1 Foreach与Transform
###7.2 Reactor风格的编程
###7.3 Reactor与Linq
###7.4 Linq的C++实践
###7.5 更高更快更强：
2014-02-14 13:18:56 +08:00
## 8 结语：讨论有益，争端无用
