0 论抽象——前言
故事要从一个看起来非常简单的功能开始:
请计算两个数的和。
如果你对Python很熟悉,你一定会觉得:“哇!这太简单了!”,然后写出以下代码:
def Plus(lhs, rhs):
return lhs + rhs
那么,C语言又如何呢?你需要面对这样的问题:
/* 这里写什么?*/ Plus(/* 这里写什么?*/ lhs, /* 这里写什么?*/ rhs)
{
return lhs + rhs;
}
也许你很快就能想到以下解法中的一些或全部:
- 硬编码为某个特定类型:
int Plus(int lhs, int rhs)
{
return lhs + rhs;
}
显然,这不是一个好的方案。因为这样的Plus函数接口强行的要求两个实参以及返回值的类型都必须是int,或是能够发生隐式类型转换到int的类型。此时,如果实参并不是int类型,其结果往往就是错误的。请看以下示例:
int main()
{
printf("%d\n", Plus(1, 2)); // 3,正确
printf("%d\n", Plus(1.999, 2.999)); // 仍然是3!
}
- 针对不同类型,定义多个函数
int Plusi(int lhs, int rhs)
{
return lhs + rhs;
}
long Plusl(long lhs, long rhs)
{
return lhs + rhs;
}
double Plusd(double lhs, double rhs)
{
return lhs + rhs;
}
// ...
这种方案的缺点也很明显:其使得代码写起来像“汇编语言”(movl,movq,...)。我们需要针对不同的类型调用不同名称的函数(是的,C语言也不支持函数重载),这太可怕了。
- 使用宏
#define Plus(lhs, rhs) (lhs + rhs)
这种方案似乎很不错,甚至“代码看上去和Python一样”。但正如许许多多的书籍都讨论过的那样,宏,不仅“抛弃”了类型,甚至“抛弃”了代码。是的,宏不是C语言代码,其只是交付于预处理器执行的“复制粘贴”的标记。一旦预处理完成,宏已然不再存在。可想而知,在功能变得复杂后,宏的缺点将会越来越大:代码晦涩,无法调试,“莫名其妙”的报错...
看到这里,也许你会觉得:“哇!C语言真烂!居然连这么简单的功能都无法实现!”。但请想一想,为什么会出现这些问题呢?让我们回到故事的起点:
请计算两个数的和。
仔细分析这句话:“请计算...的和”,意味着“加法”语义,这在C语言中可以通过“+”实现(也许你会联想到汇编语言中的加法实现);而“两个”,则意味着形参的数量是2(也许你会联想到汇编语言中的ESS、ESP、EBP等寄存器);那么,“数”,意味着什么语义?C语言中,具有“数”这一语义的类型有十几种:int、double、unsigned,等等,甚至char也具有“数”的语义。那么,“加法”和“+”,“两个”和“形参的数量是2”,以及“数”和int、double、unsigned等等之间的关系是什么?
是抽象。
高级语言的目的,就是对比其更加低级的语言进行抽象,从而使得我们能够实现更加高级的功能。抽象,是一种人类的高级思维活动,是一种充满着智慧的思维活动。汇编语言抽象了机器语言,而C语言则进一步抽象了汇编语言:其将汇编语言中的各种加法指令,抽象成了一个简单的加号;将各种寄存器操作,抽象成了形参和实参...抽象思维是如此的普遍与自然,以至于我们往往甚至忽略了这种思维的存在。
但是,C语言并没有针对类型进行抽象的能力,C语言不知道,也没有能力表达“int和double都是数字”这一语义。而这,直接导致了这个“看起来非常简单的功能”难以完美的实现。
针对类型的抽象是如此重要,以至于编程语言世界出现了与C语言这样的“静态类型语言”完全不一样的“动态类型语言”。正如开头所示,在Python这样的动态类型语言中,我们根本就不需要为每个变量提供类型,从而似乎“从根本上解决了问题”。但是,“出来混,迟早要还的”,这种看似完美的动态类型语言,牺牲的却是极大的运行时效率!我们不禁陷入了沉思:真的没有既不损失效率,又能对类型进行抽象的方案了吗?
正当我们一筹莫展,甚至感到些许绝望之时,C++的模板,为我们照亮了前行的道路。
1 新手村——模板基础
1.1 函数模板与类模板
模板,即C++中用以实现泛型编程思想的语法组分。模板是什么?一言以蔽之:类型也可以是“变量”的东西。这样的“东西”,在C++中有二:函数模板和类模板。
通过在普通的函数定义和类定义中前置template <...>,即可定义一个模板,让我们以上文中的Plus函数进行说明。请看以下示例:
此为函数模板:
template <typename T>
T Plus(T lhs, T rhs)
{
return lhs + rhs;
}
int main()
{
cout << Plus(1, 2) << endl; // 3,正确!
cout << Plus(1.999, 2.999) << endl; // 4.998,同样正确!
}
此为类模板:
template <typename T>
struct Plus
{
T operator()(T lhs, T rhs)
{
return lhs + rhs;
}
};
int main()
{
cout << Plus<int>()(1, 2) << endl; // 3,正确!
cout << Plus<double>()(1.999, 2.999) << endl; // 4.998,同样正确!
}
显然,模板的出现,使得我们轻而易举的就实现了类型抽象,并且没有(像动态类型语言那样)引入任何因为此种抽象带来的额外代价。
1.2 模板形参、模板实参与默认值
请看以下示例:
template <typename T>
struct Plus
{
T operator()(T lhs, T rhs)
{
return lhs + rhs;
}
};
int main()
{
cout << Plus<int>()(1, 2) << endl;
cout << Plus<double>()(1.999, 2.999) << endl;
}
上例中,typename T中的T,称为模板形参;而Plus<int>中的int,则称为模板实参。在这里,模板实参是一个类型。
事实上,模板的形参与实参既可以是类型,也可以是值,甚至可以是“模板的模板”;并且,模板形参也可以具有默认值(就和函数形参一样)。请看以下示例:
template <typename T, int N, template <typename U, typename = allocator<U>> class Container = vector>
class MyArray
{
Container<T> __data[N];
};
int main()
{
MyArray<int, 3> _;
}
上例中,我们声明了三个模板参数:
- typename T:一个普通的类型参数
- int N:一个整型参数
- template <typename U, typename = allocator<U>> class Container = vector:一个“模板的模板参数”
什么叫“模板的模板参数”?这里需要明确的是:模板、类型和值,是三个完全不一样的语法组分。模板能够“创造”类型,而类型能够“创造”值。请参考以下示例以进行辨析:
vector<int> v;
此例中,vector是一个模板,vector<int>是一个类型,而v是一个值。
所以,一个“模板的模板参数”,就是一个需要提供给其一个模板作为实参的参数。对于上文中的声明,Container是一个“模板的模板参数”,其需要接受一个模板作为实参 。需要怎样的模板呢?这个模板应具有两个模板形参,且第二形参具有默认值allocator<U>;同时,Container具有默认值vector,这正是一个符合要求的模板。这样,Container在类定义中,便可被当作一个模板使用(就像vector那样)。
1.3 特化与偏特化
模板,代表了一种泛化的语义。显然,既然有泛化语义,就应当有特化语义。特化,使得我们能为某些特定的类型专门提供一份特殊实现,以达到某些目的。
特化分为全特化与偏特化。所谓全特化,即一个“披着空空如也的template <>的普通函数或类”,我们还是以上文中的Plus函数为例:
// 不管T是什么类型,都将使用此定义...
template <typename T>
T Plus(T lhs, T rhs)
{
return lhs + rhs;
}
// ...但是,当T为int时,将使用此定义
template <> // 空空如也的template <>
int Plus(int lhs, int rhs)
{
return lhs + rhs;
}
int main()
{
Plus(1., 2.); // 使用泛型版本
Plus(1, 2); // 使用特化版本
}
那么,偏特化又是什么呢?除了全特化以外的特化,都称为偏特化。这句话虽然简短,但意味深长,让我们来仔细分析一下:首先,“除了全特化以外的...”,代表了template关键词之后的“<>”不能为空,否则就是全特化,这显而易见;其次,“...的特化”,代表了偏特化也必须是一个特化。什么叫“是一个特化”呢?只要特化版本比泛型版本更特殊,那么此版本就是一个特化版本。请看以下示例:
// 泛化版本
template <typename T, typename U>
struct _ {};
// 这个版本的特殊之处在于:仅当两个类型一样的时候,才会且一定会使用此版本
template <typename T>
struct _<T, T> {};
// 这个版本的特殊之处在于:仅当两个类型都是指针的时候,才会且一定会使用此版本
template <typename T, typename U>
struct _<T *, U *> {};
// 这个版本“换汤不换药”,没有任何特别之处,所以不是一个特化,而是错误的重复定义
template <typename A, typename B>
struct _<A, B> {};
由此可见,“更特殊”是一个十分宽泛的语义,这赋予了模板极大的表意能力,我们将在下面的章节中不断的见到特化所带来的各种技巧。
1.4 惰性实例化
函数模板不是函数,而是一个可以生成函数的语法组分;同理,类模板也不是类,而是一个可以生成类的语法组分。我们称通过函数模板生成函数,或通过类模板生成类的过程为模板实例化。
模板实例化具有一个非常重要的特征:惰性。这种惰性主要体现在类模板上。请看以下示例:
template <typename T>
struct Test
{
void Plus(const T &val) { val + val; }
void Minus(const T &val) { val - val; }
};
int main()
{
Test<string>().Plus("abc");
Test<int>().Minus(0);
}
上例中,Minus函数显然是不适用于string类型的。也就是说,Test类对于string类型而言,并不是“100%完美的”。当遇到这种情况时,C++的做法十分宽松:不完美?不要紧,只要不调用那些“不完美的函数”就行了。在编译器层面,编译器只会实例化真的被使用的函数,并对其进行语法检查,而根本不会在意那些根本没有被用到的函数。也就是说,在上例中,编译器实际上只实例化出了两个函数:string版本的Plus,以及int版本的Minus。
在这里,“懒惰即美德”占了上风。
1.5 依赖型名称
在C++中,“::”表达“取得”语义。显然,“::”既可以取得一个值,也可以取得一个类型。这在非模板场景下是没有任何问题的,并不会引起接下来即将将要讨论的“取得的是一个类型还是一个值”的语义混淆,因为编译器知道“::”左边的语法组分的定义。但在模板中,如果“::”左边的语法组分并不是一个确切类型,而是一个模板参数的话,语义将不再是确定的。请看以下示例:
struct A { typedef int TypeOrValue; };
struct B { static constexpr int TypeOrValue = 0; };
template <typename T>
struct C
{
T::TypeOrValue; // 这是什么?
};
上例中,如果T是A,则T::TypeOrValue是一个类型;而如果T是B,则T::TypeOrValue是一个数。我们称这种含有模板参数的,无法立即确定语义的名称为“依赖型名称”。所谓“依赖”,意即此名称的确切语义依赖于模板参数的实际类型。
对于依赖型名称,C++规定:默认情况下,编译器应认为依赖型名称不是一个类型;如果需要编译器将依赖型名称视为一个类型,则需要前置typename关键词。请看以下示例以进行辨析:
T::TypeOrValue * N; // T::TypeOrValue是一个值,这是一个乘法表达式
typename T::TypeOrValue * N; // typename T::TypeOrValue是一个类型,声明了一个这样类型的指针
1.6 可变参数模板
可变参数模板是C++11引入的一个极为重要的语法。这里对其进行简要介绍。
可变参数模板表达了“参数数量,以及每个参数的类型都未知且各不相同”这一语义。如果我们希望实现一个简单的print函数,其能够传入任意数量,且类型互不相同的参数,并依次打印这些参数值,此时就需要使用可变参数模板。
可变参数模板的语法由以下组分构成:
- typename...:声明一个可变参数模板形参
- sizeof...:获取参数包内参数的数量
- Pattern...:以某一模式展开参数包
接下来,我们就基于可变参数模板,实现这一print函数。请看以下示例:
// 递归终点
void print() {}
// 分解出一个val + 剩下的所有val
// 相当于:void print(const T &val, const Types1 &Args1, const Types2 &Args2, const Types3 &Args3, ...)
template <typename T, typename... Types>
void print(const T &val, const Types &... Args)
{
// 每次打印一个val
cout << val << endl;
// 相当于:print(Args1, Args2, Args3, ...);
// 递归地继续分解...
print(Args...);
}
int main()
{
print(1, 2., '3', "4");
}
上例中,我们实现了一对重载的print函数。第一个print函数是一个空函数,其将在“Args...”是空的时候被调用,以作为递归终点;而第二个print函数接受一个val以及余下的所有val作为参数,其将打印val,并使用余下的所有val继续递归调用自己。不难发现,第二版本的print函数具有不断打印并分解Args的能力,直到Args被完全分解。
2 平淡无奇却暗藏玄机的语法——sizeof与SFINAE
2.1 sizeof
“sizeof?这有什么可讨论的?”也许你会想。只要你学过C语言,那么对此必不陌生。那么为什么我们还需要为sizeof这一“平淡无奇”的语法单独安排一节来讨论呢?这是因为sizeof有两个对于泛型编程而言极为重要的特性:
- sizeof的求值结果是编译期常量(从而可以作为模板实参使用)
- 在任何情况下,sizeof都不会引发对其参数的求值或类似行为(如函数调用,甚至函数定义!等),因为并不需要
上述第一点很好理解,因为sizeof所考察的是类型,而类型(当然也包含其所占用的内存大小),一定是一个编译期就知道的量(因为C++作为一门静态类型语言,任何的类型都绝不会延迟到运行时才知道,这是动态类型语言才具有的特性),故sizeof的结果是一个编译期常量也就不足为奇了。
上述第二点意味深长。利用此特性,我们可以实现出一些非常特殊的功能。请看下一节。
2.2 稻草人函数
让我们以一个问题引出这一节的内容:
如何实现:判定类型A是否能够基于隐式类型转换转为B类型?
乍看之下,这是个十分棘手的问题。此时我们应当思考的是:如何引导(请注意“引导”一词的含义)编译器,在A到B的隐式类型转换可行时,走第一条路,否则,走第二条路?
请看以下示例:
template <typename A, typename B>
class IsCastable
{
private:
// 定义两个内存大小不一样的类型,作为“布尔值”
typedef char __True;
typedef struct { char _[2]; } __False;
// 稻草人函数
static A __A();
// 只要A到B的隐式类型转换可用,重载确定的结果就是此函数...
static __True __Test(B);
// ...否则,重载确定的结果才是此函数(“...”参数的重载确定优先级低于其他一切可行的重载版本)
static __False __Test(...);
public:
// 根据重载确定的结果,就能够判定出隐式类型转换是否能够发生
static constexpr bool Value = sizeof(__Test(__A())) == sizeof(__True);
};
上例比较复杂,我们依次进行讨论。
首先,我们声明了两个大小不同的类型,作为假想的“布尔值”。也许你会有疑问,这里为什么不使用int或double之类的类型作为False?这是由于C语言并未规定“int、double必须比char大”,故为了“强行满足标准”(你完全可以认为这是某种“教条主义或形式主义”),这里采用了“两个char一定比一个char大一倍”这一简单道理,定义了False。
然后,我们声明了一个所谓的“稻草人函数”,这个看似毫无意义的函数甚至没有函数体(因为并不需要,且接下来的两个函数也没有函数体,与此函数同理)。这个函数唯一的目的就是“获得”一个A类型的值“给sizeof看”。由于sizeof的不求值特性,此函数也就不需要(我们也无法提供)函数体了。那么,为什么不直接使用形如“T()”这样的写法,而需要声明一个“稻草人函数”呢?我想,不用我说你就已经明白原因了:这是因为并不是所有的T都具有默认构造函数,而如果T没有默认构造函数,那么“T()”就是错误的。
接下来是最关键的部分,我们声明了一对重载函数,这两个函数的区别有二:
- 返回值不同,一个是sizeof的结果为1的值,而另一个是sizeof的结果为2的值
- 形参不同,一个是B,一个是“...”
也就是说,如果我们给这一对重载函数传入一个A类型的值时,由于“...”参数的重载确定优先级低于其他一切可行的重载版本,只要A到B的隐式类型转换能够发生,重载确定的结果就一定是调用第一个版本的函数,返回值为__True;否则,只有当A到B的隐式类型转换真的不可行时,编译器才会“*”选择那个编译器“最不喜欢的版本”,从而使得返回值为__False。返回值的不同,就能够直接体现在sizeof的结果不同上。所以,只需要判定sizeof(__Test(__A()))是多少,就能够达到我们最终的目的了。下面请看使用示例:
int main()
{
cout << IsCastable<int, double>::Value << endl; // true
cout << IsCastable<int, string>::Value << endl; // false
}
可以看出,输出结果完全符合我们的预期。
2.3 SFINAE
SFINAE(Substitution Failure Is Not An Error,替换失败并非错误)是一个高级模板技巧。首先,让我们来分析这一拗口的词语:“替换失败并非错误”。
什么是“替换”?这里的替换,实际上指的正是模板实例化;也就是说,当模板实例化失败时,编译器并不认为这是一个错误。这句话看上去似乎莫名其妙,也许你会有疑问:那怎么样才认为是一个错误?我们又为什么要讨论一个“错误的东西”呢?让我们以一个问题引出这一技巧的意义:
如何判定一个类型是否是一个类类型?
“哇!这个问题似乎比上一个问题更难啊!”也许你会这么想。不过有了上一个问题的铺垫,这里我们依然要思考的是:一个类类型,有什么独一无二的东西是非类类型所没有的?(这样我们似乎就能让编译器在“喜欢和不喜欢”之间做出抉择)
也许你将恍然大悟:类的成员指针。
请看以下示例:
template <typename T>
class IsClass
{
private:
// 定义两个内存大小不一样的类型,作为“布尔值”
typedef char __True;
typedef struct { char _[2]; } __False;
// 仅当T是一个类类型时,“int T::*”才是存在的,从而这个泛型函数的实例化才是可行的
// 否则,就将触发SFINAE
template <typename U>
static __True __Test(int U::*);
// 仅当触发SFINAE时,编译器才会“*”选择这个版本
template <typename U>
static __False __Test(...);
public:
// 根据重载确定的结果,就能够判定出T是否为类类型
static constexpr bool Value = sizeof(__Test<T>(0)) == sizeof(__True);
};
同样,我们首先定义了两个内存大小一定不一样的类型,作为假想的“布尔值”。然后,我们声明了两个重载模板,其分别以两个“布尔值”作为返回值。这里的关键在于,重载模板的参数,一个是类成员指针,另一个是“...”。显然,当编译器拿到一个T,并准备生成一个“T: