我的C++实践(2)：模板代码的测试

C++中的模板产生类代码的过程非常复杂，而模板所表示的泛型代码还要依赖于使用模板的客户端。比如模板本身的位置、使用模板的位置、定义模板实参的位置等都会对模板的实例化产生影响。因此，模板代码的测试和调试都比较难。跟踪程序(tracer)就是一种可以跟踪模板实际调用步骤的程序，它通常是一个用户自定义的类，只定义了满足模板测试的一些功能。类的每个操作中都有一个针对该操作的跟踪（比如递增一个计数变量，以记录该操作的调用次数）。用这个类作为模板的实参来使用模板，就可以测试模板的功能。
跟踪程序是一种比较简单和行之有效的技术，它虽不能测试出模板代码中的所有错误，但可以在开发周期的早期检测出模板定义中的很多问题，这样就可以减轻后期调试的负担。当我们用C++开发模板代码时，使用跟踪程序是一种比较好的测试技巧。
下面开发一个跟踪程序Tracer，并用它测试排序算法std::sort（这是一个函数模板），这可以确认算法的效率和操作的实际调用步骤。类Tracer是跟踪程序，它可以跟踪算法运行时产生对象拷贝的份数、调用构造函数的次数、调用析构函数的次数、对象赋值的次数、对象比较的次数、现存对象的最大个数等。

//tracer.hpp：跟踪程序，一个我们定义的类
#include <iostream>
class Tracer{
private:
int value; //要被排序的整数值
int generation; //一个对象拷贝的份数
static long  n_created; //调用构造函数的次数
static long n_destroyed; //调用析构函数的次数
static long n_assigned; //赋值的次数
static long n_compared; //比较的次数
static long n_max_live; //现存对象的最大个数
//重新计算现存对象的最大个数
static void update_max_live(){
if(n_created-n_destroyed>n_max_live){
n_max_live=n_created-n_destroyed;
}
}
public:
static long creations(){
return n_created;
}
static long destructions(){
return n_destroyed;
}
static long assignments(){
return n_assigned;
}
static long comparisons(){
return n_compared;
}
static long max_live(){
return n_max_live;
}
public:
//构造函数
Tracer(int v=0):value(v),generation(1){ //首次创建：产生对象的第一份拷贝
++n_created;
update_max_live();
//表示第n_created次创建对象（直接创建），被创建为第generation份拷贝
//（首次创建时表示第1份拷贝），total表示现存对象的总个数
std::cerr<<"Tracer creation #"<<n_created
<<", created as generation "<<generation
<<" (total: "<<n_created-n_destroyed<<")/n";
}
//拷贝构造函数
Tracer(Tracer const& b):value(b.value),generation(b.generation+1){ //给对象b增加一份拷贝
++n_created;
update_max_live();
//表示第n_created次创建对象（复制创建），被复制为第generation份拷贝
std::cerr<<"Tracer creation #"<<n_created
<<", copied as generation "<<generation
<<" (total: "<<n_created-n_destroyed<<")/n";
}
//析构函数
~Tracer(){
++n_destroyed;
update_max_live();
//表示第n_destroyed次销毁对象，对象当前的第generation份拷贝被销毁
std::cerr<<"Tracer destruction #"<<n_destroyed<<", generation "<<generation
<<" destroyed (total: "<<n_created-n_destroyed<<")/n";
}
//赋值运算符
Tracer& operator=(Tracer const& b){
if(this==&b) return *this;
++n_assigned;
//表示第n_assigned次赋值：把右边对象的第b.generation份拷贝赋给左边对象的第generation份拷贝
std::cerr<<"Tracer assignment #"<<n_assigned
<<" (generation "<<generation<<" = "<<b.generation<<")/n";
value=b.value;
return *this;
}
//比较运算符
friend bool operator<(Tracer const& a,Tracer const& b){
++n_compared;
//表示第n_compared次比较：把左边对象的第a.generation份拷贝与右边对象
//的第b.generation份拷贝作<比较
std::cerr<<"Tracer comparison #"<<n_compared
<<" (generation "<<a.generation<<" < "<<b.generation<<")/n";
return a.value<b.value;
}
int val() const {
return value;
}
};
long Tracer::n_created=0;
long Tracer::n_destroyed=0;
long Tracer::n_max_live=0;
long Tracer::n_assigned=0;
long Tracer::n_compared=0;

用这个跟踪程序来测试排序算法。如下：

//tracertest.cpp：用跟踪程序来测试std::sort这个函数模板的功能
#include <iostream>
#include <algorithm>
#include "tracer.hpp"
int main(){
//准备输入的例子：构造函数会对给定的整数值执行隐式转换
Tracer input[]={7,3,5,6,4,2,0,1,9,8};
//输出初始值
for(int i=0;i<10;++i)
std::cerr<<input[i].val()<<' ';
std::cerr<<std::endl;
//存取初始状态
long created_at_start=Tracer::creations();
long max_live_at_start=Tracer::max_live();
long assigned_at_start=Tracer::assignments();
long compared_at_start=Tracer::comparisons();
//执行算法
std::cerr<<"/n/n---[ Start std::sort() ]--------------------------------------------------/n/n";
std::sort<>(&input[0],&input[9]+1);
std::cerr<<"/n/n---[ End std::sort() ]----------------------------------------------------/n/n";
//确认结果
for(int i=0;i<10;++i)
std::cerr<<input[i].val()<<' ';
std::cerr<<"/n/n";
//最后的输出报告
std::cerr<<"Statistics: "<<std::endl;
std::cerr<<"std::sort() of 10 Tracer's was performed by:/n"
<<Tracer::creations()-created_at_start<<" temporary tracers/n"<<"up to "
<<Tracer::max_live()<<" tracers at the same time ("
<<max_live_at_start<<" before)/n"
<<Tracer::assignments()-assigned_at_start<<" assignments/n"
<<Tracer::comparisons()-compared_at_start<<" comparsions/n/n";
}

运行结果如下：

zhouhuansheng@laptop-zhou:~/zhou/code/cpp_templates/basics$ g++ -Wall tracertest.cpp -o tracertest
zhouhuansheng@laptop-zhou:~/zhou/code/cpp_templates/basics$ ./tracertest
Tracer creation #1, created as generation 1 (total: 1)
Tracer creation #2, created as generation 1 (total: 2)
Tracer creation #3, created as generation 1 (total: 3)
Tracer creation #4, created as generation 1 (total: 4)
Tracer creation #5, created as generation 1 (total: 5)
Tracer creation #6, created as generation 1 (total: 6)
Tracer creation #7, created as generation 1 (total: 7)
Tracer creation #8, created as generation 1 (total: 8)
Tracer creation #9, created as generation 1 (total: 9)
Tracer creation #10, created as generation 1 (total: 10)
7 3 5 6 4 2 0 1 9 8
---[ Start std::sort() ]--------------------------------------------------
Tracer creation #11, copied as generation 2 (total: 11)
Tracer comparison #1 (generation 2 < 1)
Tracer assignment #1 (generation 1 = 1)
Tracer assignment #2 (generation 1 = 2)
Tracer destruction #1, generation 2 destroyed (total: 10)
Tracer creation #12, copied as generation 2 (total: 11)
Tracer comparison #2 (generation 2 < 1)
Tracer creation #13, copied as generation 3 (total: 12)
Tracer comparison #3 (generation 3 < 1)
Tracer assignment #3 (generation 1 = 1)
Tracer comparison #4 (generation 3 < 1)
Tracer assignment #4 (generation 1 = 3)
Tracer destruction #2, generation 3 destroyed (total: 11)
Tracer destruction #3, generation 2 destroyed (total: 10)
Tracer creation #14, copied as generation 2 (total: 11)
Tracer comparison #5 (generation 2 < 1)
Tracer creation #15, copied as generation 3 (total: 12)
Tracer comparison #6 (generation 3 < 1)
Tracer assignment #5 (generation 1 = 1)
Tracer comparison #7 (generation 3 < 1)
Tracer assignment #6 (generation 1 = 3)
Tracer destruction #4, generation 3 destroyed (total: 11)
Tracer destruction #5, generation 2 destroyed (total: 10)
Tracer creation #16, copied as generation 2 (total: 11)
Tracer comparison #8 (generation 2 < 1)
Tracer creation #17, copied as generation 3 (total: 12)
Tracer comparison #9 (generation 3 < 1)
Tracer assignment #7 (generation 1 = 1)
Tracer comparison #10 (generation 3 < 1)
Tracer assignment #8 (generation 1 = 1)
Tracer comparison #11 (generation 3 < 1)
Tracer assignment #9 (generation 1 = 1)
Tracer comparison #12 (generation 3 < 1)
Tracer assignment #10 (generation 1 = 3)
Tracer destruction #6, generation 3 destroyed (total: 11)
Tracer destruction #7, generation 2 destroyed (total: 10)
Tracer creation #18, copied as generation 2 (total: 11)
Tracer comparison #13 (generation 2 < 1)
Tracer assignment #11 (generation 1 = 1)
Tracer assignment #12 (generation 1 = 1)
Tracer assignment #13 (generation 1 = 1)
Tracer assignment #14 (generation 1 = 1)
Tracer assignment #15 (generation 1 = 1)
Tracer assignment #16 (generation 1 = 2)
Tracer destruction #8, generation 2 destroyed (total: 10)
Tracer creation #19, copied as generation 2 (total: 11)
Tracer comparison #14 (generation 2 < 1)
Tracer assignment #17 (generation 1 = 1)
Tracer assignment #18 (generation 1 = 1)
Tracer assignment #19 (generation 1 = 1)
Tracer assignment #20 (generation 1 = 1)
Tracer assignment #21 (generation 1 = 1)
Tracer assignment #22 (generation 1 = 1)
Tracer assignment #23 (generation 1 = 2)
Tracer destruction #9, generation 2 destroyed (total: 10)
Tracer creation #20, copied as generation 2 (total: 11)
Tracer comparison #15 (generation 2 < 1)
Tracer creation #21, copied as generation 3 (total: 12)
Tracer comparison #16 (generation 3 < 1)
Tracer assignment #24 (generation 1 = 1)
Tracer comparison #17 (generation 3 < 1)
Tracer assignment #25 (generation 1 = 1)
Tracer comparison #18 (generation 3 < 1)
Tracer assignment #26 (generation 1 = 1)
Tracer comparison #19 (generation 3 < 1)
Tracer assignment #27 (generation 1 = 1)
Tracer comparison #20 (generation 3 < 1)
Tracer assignment #28 (generation 1 = 1)
Tracer comparison #21 (generation 3 < 1)
Tracer assignment #29 (generation 1 = 1)
Tracer comparison #22 (generation 3 < 1)
Tracer assignment #30 (generation 1 = 3)
Tracer destruction #10, generation 3 destroyed (total: 11)
Tracer destruction #11, generation 2 destroyed (total: 10)
Tracer creation #22, copied as generation 2 (total: 11)
Tracer comparison #23 (generation 2 < 1)
Tracer creation #23, copied as generation 3 (total: 12)
Tracer comparison #24 (generation 3 < 1)
Tracer assignment #31 (generation 1 = 3)
Tracer destruction #12, generation 3 destroyed (total: 11)
Tracer destruction #13, generation 2 destroyed (total: 10)
Tracer creation #24, copied as generation 2 (total: 11)
Tracer comparison #25 (generation 2 < 1)
Tracer creation #25, copied as generation 3 (total: 12)
Tracer comparison #26 (generation 3 < 1)
Tracer assignment #32 (generation 1 = 1)
Tracer comparison #27 (generation 3 < 1)
Tracer assignment #33 (generation 1 = 3)
Tracer destruction #14, generation 3 destroyed (total: 11)
Tracer destruction #15, generation 2 destroyed (total: 10)
---[ End std::sort() ]----------------------------------------------------
0 1 2 3 4 5 6 7 8 9
Statistics:
std::sort() of 10 Tracer's was performed by:
15 temporary tracers
up to 12 tracers at the same time (10 before)
33 assignments
27 comparsions
Tracer destruction #16, generation 1 destroyed (total: 9)
Tracer destruction #17, generation 1 destroyed (total: 8)
Tracer destruction #18, generation 1 destroyed (total: 7)
Tracer destruction #19, generation 1 destroyed (total: 6)
Tracer destruction #20, generation 1 destroyed (total: 5)
Tracer destruction #21, generation 1 destroyed (total: 4)
Tracer destruction #22, generation 1 destroyed (total: 3)
Tracer destruction #23, generation 1 destroyed (total: 2)
Tracer destruction #24, generation 1 destroyed (total: 1)

这里“Tracer creation #1, created as generation 1 (total: 1)“表示第1次创建对象（直接创建），被创建为第generation份拷贝（首次创建时表示第1份拷贝，以后调用复制构造函数时，拷贝份数会增加），total表示现存对象的总个数。
“Tracer creation #11, copied as generation 2 (total: 11)“表示第11次创建对象（通过复制构造函数创建），被复制为第generation份拷贝。
“Tracer comparison #1 (generation 2 < 1)“表示第1次比较，比较左边对象的第2份拷贝是否小于右边对象的第1份拷贝。
“Tracer assignment #1 (generation 1 = 1)“表示第1次赋值：把右边对象的第1份拷贝赋给左边对象的第1份拷贝。
“Tracer destruction #1, generation 2 destroyed (total: 10)“表示第1次销毁对象，当前对象的第2份拷贝被销毁。
从最后的统计报告中可以看出，对10个对象运行std::sort算法进行排序，总共创建了15个临时对象，但在同一时刻最多只存在2个多余的对象（最多有12个，减去要排序的10），这让我们对算法的开销有了基本的把握。运行也说明了我们的tracer完全满足标准sort()算法的要求，例如不需要运算符==和运算符>。从输出的排序结果可以看出基本上没有问题。特别要注意这只是一个大概的判断，它并不能断定算法的内部代码实现的完全正确性。

对tracer增加断言和推理，或者连接到推理引擎（是一个程序，可以记住用来推导出结论的断言和推理）等，就可以扩展成所谓的oracles（测试谕示）。oracles可以动态地验证算法，它不需要完全指定模板实参（oracles本身就是实参），也不需要在程序中指定输入数据（推理引擎会请求用户来输入）。当前使用oracles对算法复杂度的分析也是非常有限的。
tracer是跟踪模板所需要的最小接口。当tracer不产生运行期输出时，我们有时也称之为archetype（原型）。利用archetype我们可以验证模板是否会请求不符合期望的语法约束。对于一个模板的实现，我们一般要为模板库中标记的每个concept都开发一个archetype。