深入探讨vc下C++模板编译模型

Love The Way You Lie 2022-02-21 10:10 279阅读 0赞

写过模板的朋友也许知道，一个模板程序，当编译器看到模板定义时并不立即产生代码，只有在我们用到模板，并对其实例化的时候，才会产生特定的实例。此时，编译器就要访问定义模板的源代码了。如果源代码不可访问，当然，编译器会报错的。记得我初学的时候，采用的是直接将声明和实现全部放在一个.h里面这个方法。但是，有时候我们确实想在.h文件中声明，在CPP文件中实现，从而实现文件分离。那么下面我就写写一般模板函数，模板类，模板特化的文件分离，我自己的心得。

在《C++primer》 中讲解了C++ 编译模板代码的两种模型 ：(1)包含编译 (2)分别编译

(1)包含编译模型:可以通过在声明函数模板或类模板的头文件中添加一条\#include指示使定义可用,从而引入包含相关定义的源文件

>   
> 
> 
> **\[cpp\]** [view plain][] [copy][view plain]
> 
> 1.  // header file utlities.h
> 2.  \#ifndef UTLITIES\_H
> 3.  \#define UTLITIES\_H
> 4.  **template** <**class** T> **int** compare(**const** T&, **const** T&); 
> 5.  ...... 
> 6.  \#include "utilities.cpp"
> 7.  \#endif
> 
> **\[cpp\]** [view plain][] [copy][view plain]
> 
> 1.  //implementation file utlities.cpp
> 2.  **template** <**class** T> **int** compare(**const** T &v1,**const** T &v2) 
> 3.  \{ 
> 4.  //implemente
> 5.   ...... 
> 6.  \}

这一策略，实现了头文件和源文件的分离

（2）分别编译： 在分别编译模式下，函数模板的声明被放在头文件中。在这种模式下，函数模板声明和定义的组织方式与程序中的非内联函数的声明和定义组织方式相同。分别编译模型 只是在使用了关键字"export"来告诉编译器模板定义在哪里引用.

如果在头文件类声明中使用了export,则该头文件只能被源文件使用一次;如果在实现文件中使用了export，有下面两种用法

导出类

**\[cpp\]** [view plain][] [copy][view plain]

1.  // XXXXX.H 文件中 定义类 
2.  **template** <**typename** Type> **class** Test\{ /\*...\*/\}; 
3.  // 在XXXXX.CPP 文件中 
4.   export **template** <**typename** Type> **class** Test; 
5.  \#include"XXXXX.h" 
6.   ...//实现类成员<

导出类成员函数,只用分别对成员使用export.

**\[cpp\]** [view plain][] [copy][view plain]

1.  // XXXXX.H 文件中 只声明
2.  **template** <**typename** Type> Type max( Type t1, Type t2 ); 
3.  // 在XXXXX.CPP 文件中
4.  // 模板定义
5.  export **template** <**typename** Type> 
6.  Type max( Type t1, Type t2 ) \{ /\* . . . \*/\}

看到这儿，你也许心花怒放，似乎觉得如此简单。好，于是你回家敲代码，你会发现，你的编译器VS照样可能告诉你错了！

首先告诉你，一部分原因是编译器问题，VS并不支持分别编译。也就是说，如果你按照上面分别编译的策略来编写代码，编译器会告诉你，目前我们不提供对关键字export的支持，也许将来会提供的支持的。不仅如此 vc的各个版本对C++的标准模板也支持程度也不尽相同，如vc6.0 并不支持模板的部分特化 等...

然后也许你采用的是第一种包含编译，包含编译是所有编译器都支持的，但是你会发现，仍然有错。我们来看下面的一段代码：

在头文件中

**\[cpp\]** [view plain][] [copy][view plain]

1.  \#ifndef tmp\_h
2.  \#define tmp\_h
3.  \#include <iostream>
4.  \#include<vector>
5.  **using****namespace** std; 
6.  
7.  **template**<**typename** T> 
8.  **class** Worker 
9.  \{ 
10. **public**: 
11. **typename** vector<T>::size\_type sz; 
12.  T test(**const** T& t1); 
13. \}; 
14. 
15. \#include "tmp.cpp"
16. \#endif

在CPP文件中

**\[cpp\]** [view plain][] [copy][view plain]

1.  \#include"tmp.h"
2.  
3.  **template**<**typename** ch> 
4.  **void** Display(string str);//这个函数是我在其他文件中实现的一个函数，不影响我们讨论的结果
5.  
6.  **template**<**typename** T> 
7.  T Worker<T>::test(**const** T& t1) 
8.  \{ 
9.   string str = "worker::test is Running!"; 
10.  ::Display<**char**>(str); 
11. **return** t1; 
12. \}

然后在另一个文件中调用

**\[cpp\]** [view plain][] [copy][view plain]

1.  **void** main() 
2.  \{ 
3.   Worker<**int**> w1; 
4.   w1.test(12.0); 
5.   \_getch(); 
6.  \}

上面的代码满足C++ primer的策略吧，但是编译器 就是报错了：

error C2995: 'T Worker<T>::test(const T &)' : function template has already been defined

因为我们在头文件中显示的包含了相应的CPP文件，但是如果我们多个文件包含了这个头文件，CPP文件也同样会被编译多次。所以出现了上述的那些错误。为了防止包含编译带来的上述错误，我们将CPP文件这样修改下：

**\[cpp\]** [view plain][] [copy][view plain]

1.  \#ifndef tmp\_cpp
2.  \#define tmp\_cpp
3.  \#include"tmp.h"
4.  
5.  **template**<**typename** ch> 
6.  **void** Display(string str); 
7.  
8.  **template**<**typename** T> 
9.  T Worker<T>::test(**const** T& t1) 
10. \{ 
11.  string str = "worker::test is Running!"; 
12.  ::Display<**char**>(str); 
13. **return** t1; 
14. \} 
15. \#endif

CPP文件也采用预编译命令，防止其重复编译。这样问题就解决了。

也许，你以为就到此结束。编译问题似乎我们完全解决了。但是，另一种情况下，假若我们的模板函数包含一个模板的特化版本，采用这种策略，编译器仍然还是会报错。下面我们来看下面的代码：

//在func.h 中我们声明了几个模板函数（采用如上所述的策略）

**\[cpp\]** [view plain][] [copy][view plain]

1.  \#ifndef FUNC\_H
2.  \#define FUNC\_H
3.  \#include <iostream>
4.  \#include<vector>
5.  \#include<iterator>
6.  \#include<algorithm>
7.  **using****namespace** std; 
8.  
9.  **template**<**typename** ch> **void** Display(string str); 
10. **template**<**typename** Type> **void** Work(Type t1); 
11. **template**<>**void** Work<**int**>( **int** t1);//Work 的特化版本
12. 
13. \#include"func.cpp"
14. \#endif

//func.cpp实现如下

**\[cpp\]** [view plain][] [copy][view plain]

1.  \#ifndef FUNC\_CPP
2.  \#define FUNC\_CPP
3.  
4.  \#include "func.h"
5.  
6.  **template**<**typename** ch> 
7.  **void** Display(string str) 
8.  \{ 
9.   ostream\_iterator<**char**>out\_it(cout, ""); 
10.  copy(str.begin(), str.end(), out\_it); 
11.  \*out\_it = '\\n'; 
12. \}; 
13. 
14. **template**<**typename** Type> 
15. **void** Work(Type t1) 
16. \{ 
17.  string txt = "Work func nomal is runing !"; 
18.  Display<**char**>(txt); 
19. \} 
20. 
21. 
22. **template**<**typename** Type,**int** Num> 
23. Type Sum(**const** Type& t1, **int** Num) 
24. \{ 
25.  string txt = "The sum of t1+Num is: "; 
26. 
27.  Type tp = t1+Num; 
28.  Display<**char**>(txt); 
29.  cout<<tp<<endl; 
30. **return** tp; 
31. \} 
32. 
33. **template**<> 
34. **void** Work<**int**>( **int** t1) 
35. \{ 
36.  string txt = "now Work is special version."; 
37.  Display<**char**>(txt); 
38. \} 
39. \#endif

在另一个CPP文件中

**\[cpp\]** [view plain][] [copy][view plain]

1.  **void** main() 
2.  \{ 
3.  **typedef****void** (\*PTEM)(**double** t1);//定义一个指针调用一个，非特化版本的模板函数
4.   PTEM pTem = Work; 
5.   pTem(3232.0); 
6.   Work<**int**>(323)//调用特化版本的模板函数
7.  \}

看起来没有什么问题吧，但是你编译一下，依然报错。不是么？

error LNK2005: "void \_\_cdecl Work<int>(int)" (??$Work@H@@YAXH@Z) already defined in func.obj

又是重定义！！我们明明都用了\#ifndef 这一套预编译指令了的啊，为什么在生成目标文件的时候，还是重定义了。而且只是说特化版本重定义了。其中具体的原因在于特化版本的编译机制，在这里我不想多说，因为本来这个机制比较复杂。我不能在自己都还不是完全理解的情况下，在这里班门弄斧。所以这里只说说我自己的两种处理方法 ：

1.依然采用包含编译方法，这种方法最简单。只需要将特化版本的函数，声明称inline函数 即可（其他的不变）。

**\[cpp\]** [view plain][] [copy][view plain]

1.  <span style="font-size:16px;">//头文件中
2.  **template**<> **inline****void** Work<**int**>( **int** t1); 
3.  //cpp文件中
4.  **template**<> 
5.  **inline****void** Work<**int**>( **int** t1) 
6.  \{ 
7.   string txt = "now Work is special version."; 
8.   Display<**char**>(txt); 
9.  \}</span>

记住啊这里一定要加inline！

2.抛弃包含编译，采用以前的笨办法，将基本模板函数的实现全部放在头文件中，只在头文件中声明特化版本的函数。在CPP文件中只实现特化版本的函数。

**\[cpp\]** [view plain][] [copy][view plain]

1.  \#ifndef FUNC\_H
2.  \#define FUNC\_H
3.  \#include <iostream>
4.  \#include<vector>
5.  \#include<iterator>
6.  \#include<algorithm>
7.  **using****namespace** std; 
8.  /头文件中实现基本模板函数
9.  **template**<**typename** ch> 
10. **void** Display(string str) 
11. \{ 
12.  ostream\_iterator<**char**>out\_it(cout, ""); 
13.  copy(str.begin(), str.end(), out\_it); 
14.  \*out\_it = '\\n'; 
15. \}; 
16. 
17. **template**<**typename** Type> 
18. **void** Work(Type t1) 
19. \{ 
20.  string txt = "Work func nomal is runing !"; 
21.  Display<**char**>(txt); 
22. \} 
23. **template**<> **void** Work<**int**>( **int** t1);//特化版本的声明
24. 
25. \#endif
26. 
27. CPP文件中只实现特化版本的函数
28. \#include "func.h"
29. \#ifndef FUNC\_CPP
30. \#define FUNC\_CPP
31. **template**<> 
32. **void** Work<**int**>( **int** t1) 
33. \{ 
34.  string txt = "now Work is special version."; 
35.  Display<**char**>(txt); 
36. \} 
37. 
38. \#endif

这样也能通过编译，也许你觉得第二个办法不高明。转来转去又回到了原点，所以要是不喜欢的话，还是推荐用第一种方法。

综上所述，我个人觉得，包含编译在模板程序中的确是首选，他很简单方便。（分别编译暂且不谈，因为不是每一个编译器都支持这种方式。）但是采用包含要注意有些特殊情况，如我上面例举出的例子

我觉得还有一个比较笨的办法，就是重新创建一个头文件，然后把模版的头文件fun.h和实现文件fun.cpp都包含进来，这个头文件命名为fun1.h，然后在main文件中直接包含fun1.h就好了。不过我还没有实验这种方法是否适合模版特化的情况，我觉得应该不可以吧。

[view plain]: http://blog.csdn.net/lh844386434/article/details/6713361#

发表评论取消回复

表情：

评论列表（有 0 条评论，279人围观）

还没有评论，来说两句吧...

相关阅读

相关深入理解Java内存模型：JMM问题探讨

Java内存模型（Java Memory Model，简称JMM）是Java虚拟机规范的一部分，它定义了线程如何共享和访问数据的规则。在理解和使用JMM时，可能会遇到以下一

朱雀/ 2024年09月03日 03:30/ 0 赞/ 115 阅读

相关 C/C++语言中struct的深入探讨

文章整理自： [http://blog.csdn.net/ehui928/article/details/546386][http_blog.csdn.net_ehui928

太过爱你忘了你带给我的痛/ 2022年08月19日 01:46/ 0 赞/ 211 阅读

相关 C++编译机制（vc++）

> 2015年9月10日早上10点，面试京东数字营销业务部机器学习系统架构工程师，二面挂在了C++编译机制上面，当然自己平时没有了解过这方面的东西，挂了也算是理所当然。网上

缺乏、安全感/ 2022年08月05日 10:30/ 0 赞/ 185 阅读

相关深入探讨PageRank

[深入探讨PageRank（一）：PageRank算法原理入门][PageRank_PageRank] http://blog.csdn.net/monkey\_d\_men

ゞ浴缸里的玫瑰/ 2022年08月05日 05:17/ 0 赞/ 164 阅读

相关【C++】深入理解模板

1、简介模板是一种代码复用方式，其它的代码复用方式还包括继承和组合。当我们使用模板时，参数由编译器来替换，这非常像原来的宏方法，但却更清晰、更容易使用。在`C++`中，

Love The Way You Lie/ 2022年06月02日 23:11/ 0 赞/ 204 阅读

相关 C++模板深入理解

如何组织编写模板程序前言常遇到询问使用模板到底是否容易的问题，我的回答是：“模板的使用是容易的，但组织编写却不容易”。看看我们几乎每天都能遇到的模板类吧，如STL,

骑猪看日落/ 2022年05月29日 02:15/ 0 赞/ 211 阅读

相关 C++：VC++常用的编译参数

<table> <tbody> <tr> <td style="width:165px;">/Zc:inline</td> <td style="wi

╰+攻爆jí腚メ/ 2022年04月14日 04:37/ 0 赞/ 382 阅读

相关 VC++2010下编译STLport,Boost

VC++2010下编译STLport,Boost 最近在想向Boost转移，努力掌握Boost代码的过程中， STLport版本：5.2.1 Boost版本：1.4.6.

古城微笑少年丶/ 2022年03月27日 13:26/ 0 赞/ 204 阅读

相关深入探讨vc下C++模板编译模型

写过模板的朋友也许知道，一个模板程序，当编译器看到模板定义时并不立即产生代码，只有在我们用到模板，并对其实例化的时候，才会产生特定的实例。此时，编译器就要访问定义模板的源代码了

Love The Way You Lie/ 2022年02月21日 10:10/ 0 赞/ 280 阅读

相关 C++ VC++ C2662编译报错

Error C2662 'bool CListFileItem::equal2(const CListFileItem &)': cannot convert 'this' p

女爷i/ 2022年01月29日 08:04/ 0 赞/ 301 阅读