在C++里面如何用模板动态地根据函数参数来决定返回值类型?

simon25hk

manphiz,我从图书馆里借来了C++ Templates回来啃,还是不太懂...正在啃+ing
另外,我试着把这个程序放到DevC++里编译不通过,在Visual C++ 6.0也不能通过.
我想问一个问题:Visual C++6.0好像不能很好地实现某些C++的标淮,是吗?
那么,DevC++呢?

因为我还是个Templates的初学者,很多东西都不太懂,希望见谅.

另外帮我看一下这个程序到底错在哪了..我也不太懂呢T_T

1. #include <cstdlib>
   
2. #include <iostream>
   
3. 
   
4. #ifndef IFTHENELSE_HPP
   
5. #define IFTHENELSE_HPP
   
6. 
   
7. template<bool C, typename T1, typename T2>
   
8. class IfThenElse;
   
9. 
   
10. template<typename T1, typename T2>
    
11. class IfThenElse<true, T1, T2> {
    
12.   public:
    
13.     typedef T1 ResultT;
    
14. };
    
15. 
    
16. template<typename T1, typename T2>
    
17. class IfThenElse<false, T1, T2> {
    
18.   public:
    
19.     typedef T2 ResultT;
    
20. };
    
21. 
    
22. #endif
    
23. 
    
24. #ifndef PROMOTION_HPP
    
25. #define PROMOTION_HPP
    
26. 
    
27. template<typename Ta, typename Tb>
    
28. class Promotion {
    
29.   public:
    
30.     typedef typename IfThenElse<(sizeof(Ta))>(sizeof(Tb)),
    
31.                                             Ta,
    
32.                                             typename IfTheElse<(sizeof(Ta))<(sizeof(Tb)),
    
33.                                                                         Tb,
    
34.                                                                         void
    
35.                                                                        >::ResultT
    
36.                                            >::ResultT ResultT;
    
37. };
    
38. 
    
39. template<>
    
40. class Promotion<T,T> {
    
41.   public:
    
42.     typedef T ResultT;
    
43. }
    
44. 
    
45. #endif
    
46. 
    
47. 
    
48. template<>
    
49. class Promotion<char, short> {
    
50.   public:
    
51.     typedef int ResultT;
    
52. };
    
53. 
    
54. template<>
    
55. class Promotion<short, char> {
    
56.   public:
    
57.     typedef int ResultT;
    
58. };
    
59. 
    
60. template<typename T1, typename T2>
    
61. Promotion<T1, T2>::ResultT max(T1 lhs, T2 rhs)
    
62. {
    
63.   return lhs < rhs ? rhs : lhs;
    
64. }
    
65. 
    
66. using namespace std;
    
67. 
    
68. int main(int argc, char *argv[])
    
69. {
    
70.     int x = 1;
    
71.     double y = 0.5;
    
72.     cout<< max(x, y)<<endl;
    
73.     x = 3;
    
74.     y = 4.5;
    
75.     cout<< max(x, y)<<endl;
    
76.     system("PAUSE");
    
77.     return EXIT_SUCCESS;
    
78. }

复制代码

Post by manphiz
通常来讲，只有两个同类型的量才能做比较操作，即便是short->int甚至int->double，type promotion也可以保证不需要对两个量分别定义类型。

具体到问题本身，有两个方法：
1、使用指定的返回参数：

1. 
   
2. template<typename RT, typename T1, typename T2>
   
3. RT max(T1 lhs, T2 rhs)
   
4. {
   
5.   return lhs < rhs ? rhs : lhs;
   
6. }
   

复制代码

而在使用中使用下面比较笨拙的方法。

1. 
   
2. max<double>(2, 4.3);
   

复制代码

2、采用模板元编程技巧的promotion trait。
首先设计一个IfThenElse模板：

1. 
   
2. // ifthenelse.hpp
   
3. #ifndef IFTHENELSE_HPP
   
4. #define IFTHENELSE_HPP
   
5. 
   
6. template<bool C, typename T1, typename T2>
   
7. class IfThenElse;
   
8. 
   
9. template<typename T1, typename T2>
   
10. class IfThenElse<true, T1, T2> {
    
11.   public:
    
12.     typedef T1 ResultT;
    
13. };
    
14. 
    
15. template<typename T1, typename T2>
    
16. class IfThenElse<false, T1, T2> {
    
17.   public:
    
18.     typedef T2 ResultT;
    
19. };
    
20. 
    
21. #endif
    

复制代码

然后设计promotion trait：

1. 
   
2. // promotion.hpp
   
3. #ifndef PROMOTION_HPP
   
4. #define PROMOTION_HPP
   
5. 
   
6. #include <ifthenelse.hpp>
   
7. template<typename Ta, typename Tb>
   
8. class Promotion {
   
9.   public:
   
10.     typedef typename IfThenElse<(sizeof(Ta))>(sizeof(Tb)),
    
11.                                             Ta,
    
12.                                             typename IfTheElse<(sizeof(Ta))<(sizeof(Tb)),
    
13.                                                                         Tb,
    
14.                                                                         void
    
15.                                                                        >::ResultT
    
16.                                            >::ResultT ResultT;
    
17. };
    
18. 
    
19. template<>
    
20. class Promotion<T,T> {
    
21.   public:
    
22.     typedef T ResultT;
    
23. }
    
24. 
    
25. #endif
    

复制代码

这样基本可以满足类型推广的需要。这样使用：

1. 
   
2. template<typename T1, typename T2>
   
3. Promotion<T1, T2>::ResultT max(T1 lhs, T2 rhs)
   
4. {
   
5.   return lhs < rhs ? rhs : lhs;
   
6. }
   

复制代码

值得注意的在整型类型的类型推广时不满足标准的规定。比如char,short->int。如果需要的话，需要创建模板特化，例如

1. 
   
2. template<>
   
3. class Promotion<char, short> {
   
4.   public:
   
5.     typedef int ResultT;
   
6. };
   
7. 
   
8. template<>
   
9. class Promotion<short, char> {
   
10.   public:
    
11.     typedef int ResultT;
    
12. };
    

复制代码

依此类推。

参考
C++ Templates: The Complete Guide, David Vandevoorde, Nicolai M. Josuttis

修改了几下，请见谅

rickxbx

仔细看来,manphiz 兄的程序有点小问题,已经帮你做了点修改:

2. #include <cstdlib>
3. #include <iostream>
5. #ifndef IFTHENELSE_HPP
6. #define IFTHENELSE_HPP
8. template<bool C, typename T1, typename T2>
9. class IfThenElse;
11. template<typename T1, typename T2>
12. class IfThenElse<true, T1, T2> {
13.   public:
14.     typedef T1 ResultT;
15. };
17. template<typename T1, typename T2>
18. class IfThenElse<false, T1, T2> {
19.   public:
20.     typedef T2 ResultT;
21. };
23. #endif
25. #ifndef PROMOTION_HPP
26. #define PROMOTION_HPP
28. template<typename Ta, typename Tb>
29. class Promotion {
30.   public:
31.     typedef typename IfThenElse<(sizeof(Ta)>sizeof(Tb)),Ta,Tb>::ResultT ResultT;
32. };
34. template<typename T>
35. class Promotion<T,T> {
36.   public:
37.     typedef T ResultT;
38. };
40. #endif
43. template<>
44. class Promotion<char, short> {
45.   public:
46.     typedef int ResultT;
47. };
49. template<>
50. class Promotion<short, char> {
51.   public:
52.     typedef int ResultT;
53. };
55. template<typename T1, typename T2>
56. typename Promotion<T1, T2>::ResultT max(T1 lhs, T2 rhs)
57. {
58.   return lhs < rhs ? rhs : lhs;
59. }
61. using namespace std;
63. int main(int argc, char *argv[])
64. {
65.     int x = 1;
66.     double y = 0.5;
67.     cout<< max(x, y)<<endl;
68.     x = 3;
69.     y = 4.5;
70.     cout<< max(x, y)<<endl;
71.     system("PAUSE");
72.     return EXIT_SUCCESS;
73. }

复制代码

manphiz

sorry，忘了两个typename，有劳rickxbx兄了...

不过rickxbx兄将Promotion的那个判断简化了，窃以为不应该。毕竟两个类型的变量大小相等并不代表两个类型是相同的，如32位系统上的int和long。因此，struct Promotion的原始形式将两个大小相等的不同类型的返回量定义为void。这种情况下实际上应该对其建立特化，将int和long统一promote到long类型。

以下是再次修改后的版本（亡羊补牢~）：

2. // ifthenelse.hpp
3. #ifndef IFTHENELSE_HPP
4. #define IFTHENELSE_HPP
6. template<bool c, typename Ta, typename Tb>
7. struct IfThenElse {};
9. template<typename Ta, typename Tb>
10. struct IfThenElse<true, Ta, Tb> {
11.         typedef Ta ResultT;
12. };
14. template<typename Ta, typename Tb>
15. struct IfThenElse<false, Ta, Tb> {
16.         typedef Tb ResultT;
17. };
19. #endif

复制代码

2. // promotion.hpp
3. #ifndef PROMOTION_HPP
4. #define PROMOTION_HPP
6. #include "ifthenelse.hpp"
8. template<typename T1, typename T2>
9. struct Promotion{
10.         typedef typename IfThenElse<(sizeof(T1)>sizeof(T2)),
11.                                     T1,
12.                                     typename IfThenElse<(sizeof(T1)<sizeof(T2)),
13.                                                         T2,
14.                                                         void
15.                                                        >::ResultT
16.                                    >::ResultT ResultT;
17. };
19. template<typename T>
20. struct Promotion<T, T> {
21.         typedef T ResultT;
22. };
24. #endif

复制代码

2. // promotion_specialize.hpp
3. #ifndef PROMOTION_SPECIALIZE_HPP
4. #define PROMOTION_SPECIALIZE_HPP
6. #include "promotion.hpp"
8. #define PROMOTION_SPECIALIZE(T1, T2, RT)        \
9. template<>                                        \
10. struct Promotion<T1, T2> {                        \
11.         typedef RT ResultT;                        \
12. };                                                \
13. template<>                                        \
14. struct Promotion<T2, T1> {                        \
15.         typedef RT ResultT;                        \
16. };
18. PROMOTION_SPECIALIZE(char, short, int);
19. PROMOTION_SPECIALIZE(int, long, long);
20. PROMOTION_SPECIALIZE(int, float, double);
21. // Add yours here
23. #endif

复制代码

2. // test.cpp
3. #include <iostream>
4. #include "promotion_specialize.hpp"
6. template<typename T1, typename T2>
7. typename Promotion<T1, T2>::ResultT max(T1 lhs, T2 rhs)
8. {
9.         return lhs < rhs ? rhs : lhs;
10. }
12. int main()
13. {
14.         char a = 1;
15.         short b = 12;
16.         std::cout << max(a, b) << std::endl;
17.         int c = 10;
18.         long d = 20;
19.         std::cout << max(c, d) << std::endl;
20.         int e = 100;
21.         float f = 1e10;
22.         std::cout << max(e, f) << std::endl;
23. }

复制代码

另：有关编译器：
Visual C++ 6是化石编译器，不支持大部分高级模板特性，如模板偏特化等。如果使用模板编程，请不要使用Visual C++ 6。VC7.1（2003）以后的版本可以考虑。
Dev-Cpp实际上是个编辑器。它默认使用MinGW gcc 3.4.2版本编译器。gcc 3.4以后对模板的支持比较好，可以放心使用。

C++ Templates是本很复杂的书，希望能仔细研究，必会大有收获。

zlbruce

收藏学习中...

MatthewGong

trait技法呀……奇技淫巧，叹为观止。

rickxbx

Post by manphiz
不过rickxbx兄将Promotion的那个判断简化了，窃以为不应该。

嗯,确实是这样

讨论了半天,貌似把楼主给冷落了,其实楼主的问题在我的能力范围内是不可解的,原因很简单,返回值类型必须在编译时就确定,而两个(或多个)值的大小关系一般要到运行时才明了(立即数要除外),所以那个问题看似无解

simon25hk

我想请教一下:
在Templates书中说要记录基本类型的提升,需要针对一系列基本类型进行特化

//traits/promote3.hpp  建立一个宏

#define MK_PROMOTION(T1,T2,Tr)                  \
     template<>class Promotion<T1,T2>     {    \
           public:                                                   \
           typedef Tr ResutlT;                                \
  };                                                                   \
      template<>class Promotion<T2,T1>     {   \
           public:                                                   \
           typedef Tr ResutlT;                               \
  };                                                                  \


//traits/promote4.hpp

MK_PROMOTION( bool, char ,int )
MK_PROMOTION( bool, unsigned char, int )
.....
.....
要枚举出几十种

为什么一定要针对这些基本类型进行类型提升,不特化可以吗?
如果按照我首贴的要求,根据那个参数大返回值就是那是那个大的.
if 我的参数有两个 bool , int
   如果bool值大于int ,应该返回bool型,但是提升后,不就变成int型了? 不解?

manphiz

类型提升实际上是模拟C/C++语言中的隐式类型转换规则。
以整数类型为例：当两个不同类型的整数进行算数运算时，为了使表达式避免复杂的类型转换语句，便定义了一套隐式类型转换规则。小整数类型（如short）能用大整数类型表示（如int），因此便定义了从小到大类型的类型转换，通常成为类型提升。这是符合习惯的。又为了整数类型值也可以用于判断语句，而这在大部分情况下不会产生歧义，因此存在整数类型到bool类型的隐式转换。
Promotion Trait因为建立在类型大小比较的基础上，因此大部分情况符合这些规则，但在基本类型提升上不符合C/C++标准的习惯，如<int类型到int，long以上数值类型到double。这种情况下便需要通过特化来描述这些行为。
当然，楼主可以根据实际需要进行取舍，保留需要的部分即可。

rickxbx

Post by manphiz
类型提升实际上是模拟C/C++语言中的隐式类型转换规则。
以整数类型为例：当两个不同类型的整数进行算数运算时，为了使表达式避免复杂的类型转换语句，便定义了一套隐式类型转换规则。小整数类型（如short）能用大整数类型表示（如int），因此便定义了从小到大类型的类型转换，通常成为类型提升。这是符合习惯的。又为了整数类型值也可以用于判断语句，而这在大部分情况下不会产生歧义，因此存在整数类型到bool类型的隐式转换。
Promotion Trait因为建立在类型大小比较的基础上，因此大部分情况符合这些规则，但在基本类型提升上不符合C/C++标准的习惯，如<int类型到int，long以上数值类型到double。这种情况下便需要通过特化来描述这些行为。
当然，楼主可以根据实际需要进行取舍，保留需要的部分即可。

很明显,你没有搞清楚楼主的目的,楼主要的不是类型提升之类的东西(因为有可能会"降"),而是想..... (请看楼主的原帖)

manphiz

Post by rickxbx
很明显,你没有搞清楚楼主的目的,楼主要的不是类型提升之类的东西(因为有可能会"降"),而是想..... (请看楼主的原帖)

呵呵，其实我明白楼主的目的。但是我想告诉楼主的是，他所希望达到的效果是不符合习惯的，而类型提升才是预想的效果。
（又没有一次说清楚，呵呵）