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

simon25hk

例如, 一个max模板,
template <typename T1, typename T2>
??? max(T1 a, T2, b)    //返回值类未知...
{
      if ( a > b)  返回a,且返回类型为T1

}

simon25hk

对不起啊,前面不小心按了提交.....

例如, 一个max模板,
template <typename T1, typename T2>
??? max(T1 a, T2, b)    //返回值类未知...
{
      if ( a > b)  返回a,且返回类型为T1
           else 返回b,且返回类型为T2
}

具体应该怎么实现啊?

manphiz

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

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

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

复制代码

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

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

复制代码

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

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

复制代码

然后设计promotion trait：

2. // promotion.hpp
3. #ifndef PROMOTION_HPP
4. #define PROMOTION_HPP
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. };
19. template<>
20. class Promotion<T,T> {
21.   public:
22.     typedef T ResultT;
23. }
25. #endif

复制代码

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

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。如果需要的话，需要创建模板特化，例如

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

复制代码

依此类推。

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

修改了几下，请见谅

soloforce

应该是很难实现的。
1、模板本身没有所谓“动态”的概念，它只是编译时根据实参进行具现化而已。
2、模板不会根据返回值类型进行推演，从而有效具现化。

个人见解，仅供参考。

你可以看看《C++ Templates : Complete Guide》

soloforce

Post by manphiz

有两个变通方法：
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);
   

复制代码

用另一个模板参数做返回类型，还是根据type promotion的吧。

2、将数值本身作为模板参数：
采用模板元编程技巧的promotion trait

这个还不太了解，学习ing

soloforce

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

复制代码

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

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

复制代码

强。学习ing~ :2cool

manphiz

Post by Lolita

2. template<typename T1, typename T2>
3. Promotion<T1, T2>[color=red]::ResultT[/color] max(T1 lhs, T2 rhs)
4. {
5.   return lhs < rhs ? rhs : lhs;
6. }

复制代码

严重疏忽，不好意思~

rickxbx

Modern C++ Design(C++ 设计新思维) 一书中把cpp的模板机制用的出神入化(呵呵,有点夸张),推荐一读.

btw:

通常来讲，只有两个同类型的量才能做比较操作

却不尽然,想cpp的操作符重载用的越来越多,不同类型之间的比较也很正常

manphiz

Post by rickxbx
想cpp的操作符重载用的越来越多,不同类型之间的比较也很正常

呵呵，又表述不清，被斑斑抓到了
其实想说的是进行比较的两个量多少应该据有相同或近似的性质，例如都是数值，或者都在一个继承体系中，因此大部分情况下两个量之间会存在隐式类型转换的可能。而这种情况下即使不使用两个类型也可以借助隐式转换完成比较。当然这样做无法避免类型推广，不过多数情况下这样的行为是可以接受的。

不过经斑斑一提醒，想到了promotion trait的默认行为在处理用户定义类型的时候可能会产生错误。因为它的类型推广思路是基于基本类型的，将类型的大小作为类型推广的标度，而用户定义类型的大小和类型推广方向通常无关，甚至会返回void。因此如果将promotion trait用于用户定义类型，最好还是建立特化的版本，以非预期的行为。

Post by rickxbx
Modern C++ Design(C++ 设计新思维) 一书中把cpp的模板机制用的出神入化(呵呵,有点夸张),推荐一读.

呵呵，这个可是惊世骇俗的大作，不过需要设计模式的知识。先学习着prerequiste……

soloforce

Post by manphiz

呵呵，这个可是惊世骇俗的大作，不过需要设计模式的知识。先学习着prerequiste……

哎，c++的惊世骇俗作品太多了，看得爽也看得累:comp