社区编辑申请
注册/登录
C++ 模板元编程之模板特化的概念从何而来
开发 后端
C++ 里的模板能做什么呢?它好比 C 语言中的宏、C# 和 Java 中的自省(restropection)和反射(reflection),是 C++ 语言的外延。

0. 前言

C++ 里的模板能做什么呢?它好比 C 语言中的宏、C# 和 Java 中的自省(restropection)和反射(reflection),是 C++ 语言的外延。更极端一点地理解:它是一门新的图灵完备的编程语言(也就是说,C++ 模板能实现图灵机模型里的全部功能)。在《Modern C++ Design》中,作者抛出了以下几个问题:

(1)如何撰写更高级的C++程式?

(2)如何应付即使在很干净的设计中仍然像雪崩一样的不相干细节?

(3)如何构建可复用组件,使得每次在不同程式中应用组件时无需大动干戈?

解决上述问题的方法就是模板元编程。元(meta)本身就是个很“抽象(abstract)”的词,因为它的本意就是“抽象”。元编程,也可以说就是“编程的抽象”。用更好理解的说法,元编程意味着你撰写一段程序A,程序A会运行后生成另外一个程序B,程序B才是真正实现功能的程序。那么这个时候程序A可以称作程序B的元程序,撰写程序A的过程,就称之为“元编程”。

C++中,元编程的手段,可以是宏,也可以是模板。

1、为什么需要泛型编程:从宏到模板,再到元编程

如果元编程中所有的变量(或者说元编程的参数),都是类型,那么这样的编程,我们有个特定的称呼,叫“泛型”。

模板的发明,仅仅是为了做和宏几乎一样的替换工作吗?可以说是,也可以说不是。

一方面,模板可以用来替换类型,这点和宏没什么区别。只是宏在编译阶段基于文本做纯粹替换,被替换的文本本身没有任何语义。而模板会在分析模板时以及实例化模板的时候都会进行检查,而且源代码中也能与调试符号一一对应,所以无论是编译时还是运行时,排错都相对简单。

另一方面,模板和宏也有很大的不同,模板最大的不同在于它是“可以运算”的。我们来看一个例子:

  1. void Add(uint8_t, unit8_t) {} 

上述函数实现了一个 uint8_t 和 uint8_t 类型的加法运算,如果现在要实现 int16 和 int16 类型的加法运算,该怎么办呢?简单点的方法如下:

  1. if (type == 8) { 
  2.     Add(uint8_t, uint8_t) 
  3. else if (type == 16) { 
  4.     Add(uint16_t, uint16_t) 

但是这里有两个难点:

  • 首先, if(type == x) 是不存在于 C++ 中的
  • 其次,即便存在获取变量 type 的方法(Boost.Any 中的 typeid ),我们也不希望它在运行时判断,这样会变得很慢。是否可以不引入 if/else,在编译期就把 Add 的方法确定呢?

有人说,重载、虚函数也能解决如上问题:

  1. void Add(uint8_t, uint8_t) {} 
  2. void Add(uint16_t, uint16_t) {} 

甚至在 C 语言中定义新的结构体 Variant 或使用 void* 也能解决该问题:

  1. struct Variant 
  2.     union 
  3.     { 
  4.         uint_8 x; 
  5.         uint_16 y; 
  6.     } data; 
  7.     uint32_t typeId; 
  8. }; 

没错,但是如果我还有 uint9_t、uint10_t 等各种类型的加法运算呢?Anyway,不管是哪种方法都很难避免 if/else 的存在。

模板与上述这些方法最大的区别在于:模板无论其参数或者是类型,它都是一个编译期分派的方法。编译期就能确定的东西既可以做类型检查,编译器也能进行优化,砍掉任何不必要的代码执行路径。

2、类模板的特化:模板世界里的 if/else

2.1 根据类型执行代码

我们先来看看一个模板的例子:

  1. template <typename T> T AddFloatOrMulInt(T a, T b); 
  2. // 我们希望这个函数在 T 是 float 的时候做加法运算,在 T 是 int 类型的时候做乘法运算 

那么当传入两个不同类型的变量,或者不是 int 和 float 变量,编译器就会提示错误。

从能力上来看,模板能做的事情都是编译期完成的。编译期完成的意思就是,当你编译一个程序的时候,所有的量就都已经确定了。比如下面的例子:

  1. int a = 3, b = 5; 
  2. Variant aVar, bVar; 
  3. aVar.setInt(a);            // 我们新加上的方法,怎么实现的无所谓,大家明白意思就行了。 
  4. bVar.setInt(b); 
  5. Variant result = AddFloatOrMulInt(aVar, bVar); 

从上述代码中我们可以看到:aVar 和 bVar 都一定会是整数。所以如果有合适的机制,编译器就能知道此处的 AddFloatOrMulInt 中只需要执行 int 路径上的代码,而且编译器在此处也能单独为 int 路径生成代码,从而去掉那个不必要的 if。在模板代码中,这个“合适的机制”就是指“特化”和“部分特化(Partial Specialization)”,后者也叫“偏特化”。

2.2、如何写模板特化的代码

1.0 版本 - 伪代码

  1. int/float AddFloatOrMulInt(a, b) // 类的静态函数 
  2.   if(type is int) { 
  3.     return a * b; 
  4.   } else if (type is float) { 
  5.     return a + b; 
  6.   } 
  7.  
  8. void foo() 
  9.     float a, b, c; 
  10.     c = addFloatOrMulInt(a, b);        // c = a + b; 
  11.  
  12.     int x, y, z; 
  13.     z = addFloatOrMulInt(x, y);        // z = x * y; 

2.0 版本 - 函数重载

  1. float AddFloatOrMulInt(float a, float b) 
  2.     return a + b; 
  3.  
  4. int AddFloatOrMulIntDo(int a, int b) 
  5.     return a * b; 
  6.  
  7. void foo() 
  8.     float a, b, c; 
  9.     c = AddFloatOrMulInt(a, b);        // c = a + b; 
  10.  
  11.     int x, y, z; 
  12.     z = AddFloatOrMulInt(x, y);        // z = x * y; 

3.0 版本 - 纯模板

  1. // 这个是给float用的。 
  2. template <typename T> class AddFloatOrMulInt 
  3.     T Do(T a, T b) 
  4.     { 
  5.         return a + b; 
  6.     } 
  7. }; 
  8.  
  9. // 这个是给int用的。 
  10. template <typename T> class AddFloatOrMulInt 
  11.     T Do(T a, T b) 
  12.     { 
  13.         return a * b; 
  14.     } 
  15. }; 
  16.  
  17. void foo() 
  18.     float a, b, c; 
  19.  
  20.     // 我们需要 c = a + b; 
  21.     c = AddFloatOrMulInt<float>::Do(a, b);         
  22.     // ... 觉得哪里不对劲 ... 
  23.     // 啊!有两个 AddFloatOrMulInt,class 看起来一模一样,要怎么区分呢! 

好吧,问题来了!如何要让两个内容不同,但是模板参数形式相同的类进行区分呢?特化!特化(specialization)是根据一个或多个特殊的整数或类型,给出模板实例化时的一个指定内容。

4.0 版本 - 模板特化

  1. // 首先,要写出模板的一般形式(原型,即初始化,不能省) 
  2. template <typename T> class AddFloatOrMulInt 
  3.     static T Do(T a, T b)  // 注意这里必须得是静态方法!!! 
  4.     { 
  5.         return T(0); 
  6.     } 
  7. }; 
  8.  
  9. // 其次,我们要指定T是float时候的代码: 
  10. template <> class AddFloatOrMulInt<float
  11. public
  12.     static float Do(float a, float b) 
  13.     { 
  14.         return a + b; 
  15.     } 
  16. }; 
  17.  
  18. // 再次,我们要指定T是int时候的代码,这就是特化: 
  19. template <> class AddFloatOrMulInt<int
  20. public
  21.     static int Do(int a, int b) //  
  22.     { 
  23.         return a * b; 
  24.     } 
  25. }; 
  26.  
  27. int foo() 
  28.     return AddFloatOrMulInt<float>::Do(1.0, 2.0); 
  29.  
  30. int main()  
  31.     std::cout << foo();  // 输出结果 3.0 

解释:

  1. // 我们这个模板的基本形式是什么? 
  2. template <typename T> class AddFloatOrMulInt; 
  3.  
  4. // 但是这个类,是给T是 int 的时候用的,于是我们写作 
  5. class AddFloatOrMulInt<int>; 
  6. // 当然,这里编译是通不过的。 
  7. // 但是它又不是个普通类,而是类模板的一个特化(特例)。 
  8. // 所以前面要加模板关键字template,以及模板参数列表 
  9. template </* 这里要填什么? */> class AddFloatOrMulInt<int>; 
  10.  
  11. // 最后,模板参数列表里面填什么?因为原型的T已经被int取代了。所以这里就不能也不需要放任何额外的参数了。所以这里放空。 
  12. template <> class AddFloatOrMulInt<int
  13.     // ... 针对 int 的实现 ...  
  14.  
  15. // Done! 

至此,第一个模板特化的代码已经写完了。这里的 AddFloatOrMulInt 如同是一个函数,却只能在编译期间执行。如果你体味到了这一点,那么恭喜你,你的模板元编程已经开悟了。

3、总结

 

本文核心只讲了两个问题:一是为什么需要泛型编程,重点介绍了宏、模板和元编程的关系;二是模板类的特化代码如何编写。关于特化,还有很多细节知识,在之后的文章中我们继续探究,另外将还介绍偏特化等知识点,敬请期待。

 

责任编辑:武晓燕 来源: 今日头条
相关推荐

2022-04-11 11:38:44

Python代码游戏

2022-04-18 12:29:18

C++

2022-05-16 10:36:08

GitHub开源项目

2022-05-10 16:04:40

编程语言PythonC语言

2022-04-20 20:28:40

HDF 驱动框架鸿蒙操作系统

2010-02-04 13:56:24

2022-03-25 09:57:18

C++Rust语言

2022-03-31 07:52:01

Java多线程并发

2022-05-20 16:50:33

区块链Web3加密资产

2022-04-11 09:39:58

Linux进程编程

2022-04-01 15:18:04

HarmonyHDF 驱动鸿蒙

2022-04-26 08:41:54

JDK动态代理方法

2022-03-16 10:14:55

C语言C++

2022-04-12 08:00:17

socket 编程网络编程网络 IO 模型

2022-04-15 10:11:03

机器学习scikit-lea

2022-04-12 11:20:11

C 语言Linux编程

2022-04-13 09:57:24

Go语言C语言程序开发

2022-04-26 09:23:07

Hare编程语言C

2022-04-19 09:24:18

QtC++框架

2022-04-29 09:43:12

IPDKAPI框架DPU/IPU

同话题下的热门内容

Python 字符串总结,建议收藏!这份Java日志格式规范,拿走不谢!Mybatis-Plus官方发布分库分表神器,一个依赖轻松搞定!后端思维篇:如何应用设计模式优化代码改变 Python 对象规则的黑魔法 Metaclass几种限流算法的Go语言实现JMeter关联之正则表达式提取器在 Go 中实现一个支持并发的 TCP 服务端

编辑推荐

使用Kotlin做开发一个月后的感想面试官问你什么是消息队列?把这篇甩给他!五大自动化测试的Python框架图文详解两种算法:深度优先遍历(DFS)和广度优先遍历(BFS)2018年最流行的十大编程语言,其中包括你用的语言吗?
我收藏的内容
点赞
收藏

51CTO技术栈公众号