C/C++编程：类型函数

秒速五厘米 2023-01-16 02:40 118阅读 0赞

在C/C++中，函数可以被称为值函数：函数接收的参数是值，返回结果也是值。而C++中有一种叫做类型函数的函数：接收的参数是类型，并且生成一个类型作为函数的返回值结果

sizeof就是一个非常有用的，内建的类型函数，它返回一个描述给定类型实参的大小(以字节为单位)的常量。另一方面，类模板也可以作为类型函数。类型函数的参数可以是模板的参数，而结果就是抽取处理的成员类型或者成员常量。比如，将sizeof修改为下面的接口：

#include <iostream>
    #include <stddef.h>
    
    
    template<typename T>
    class TypeSize{
        
    public:
        static size_t const value = sizeof(T);
    };
    int main()
    {
        
        std::cout << TypeSize<int>::value << "\n";
    }

# 确定元素的类型 #

实现类型函数：给定一个容器的类型，能够给出容器元素的类型。

#include <iostream>
    #include <vector>
    #include <list>
    #include <stack>
    
    
    template<typename T>
    class ElementT;
    
    template<typename T>
    class ElementT<std::vector<T>>{
        // 布局特化
    public:
        typedef T Type;
    };
    
    
    
    template<typename T>
    class ElementT<std::list<T>>{
        // 布局特化
    public:
        typedef T Type;
    };
    
    template<typename T>
    class ElementT<std::stack<T>>{
          // 布局特化
    public:
        typedef T Type;
    };
    
    
    template<typename T>
    void print_element_type(T const & c){
        
        std::cout << "Container of" << typeid(typename ElementT<T>::Type).name() << " elements \n";
    }
    
    
    
    int main()
    {
        
        std::stack<bool> s;
        print_element_type(s);
    }

# 确定class类型 #

类型函数功能： 确定某个类型是否为class类型

#ifndef UNTITLED_ISCLASST_H
    #define UNTITLED_ISCLASST_H
    template<typename T>
    class IsClassT{
        
    private:
        typedef char One;
        typedef struct {
        char a[2];} Two;
        template<typename C> static One test(int C::*);
        template<typename C> static Two test(...);
    
    public:
        enum {
        Yes = sizeof(IsClassT<T>::test<T>(0)) == 1};
        enum {
        NO = !Yes};
    };
    
    #endif //UNTITLED_ISCLASST_H

上面的模板用来SFINAT原则：替换失败并非错误。这里用到SFINAT原则的目的在于找到这样的一个类型构造：它对class是无效的，对其他类型是有效的；或者相反。于是，在这里我们可以依赖于下面这个事实：只有当C是一个class类型的时候，身为成员指针的类型构造`C::*`才会是有效的。

#include <iostream>
    #include <isclasst.h>
    
    class MyClass{
        };
    struct MyStruct{
        };
    union MyUnion{
        };
    void myfunc(){
        }
    enum E{
        e1, e2} e;
    
    // 以模板实参的方式传递类型
    template<typename T>
    void check(){
        
        if (IsClassT<T>::Yes){
        
            printf("IsClassT\n");
        }else{
        
            printf("!IsClassT\n");
        }
    }
    
    // 以函数调用的方式传递类型
    template<typename T>
    void checkT(T){
        
        check<T>();
    }
    
    int main()
    {
        
        printf("int:       ");
        check<int>();
    
        printf("MyClass:   ");
        check<MyClass>();
    
        printf("MyStruct:  ");
        check<MyStruct>();
    
        printf("MyUnion:   ");
        check<MyUnion>();
    
        printf("enum:      ");
        checkT(e);
    
        printf("myfunc:    ");
        checkT(myfunc);
    }

![在这里插入图片描述][20210423130509374.png]

# 引用和限定符（看不懂） #

#ifndef UNTITLED_APPLY_H
    #define UNTITLED_APPLY_H
    
    template<typename T>
    void apply(T & arg, void (*func)(T)){
        
        func(arg);
    }
    
    #endif //UNTITLED_APPLY_H

使用上面的函数模板：  
![在这里插入图片描述][20210423131054871.png]  
因为对于`apply(x, incr)`，用int&替换T，意味着类型参数为int&&， 但是int&&不是合法的C++类型。

解决方法：创建一个能够运用“引用运算符”的类型参数，但前提条件是给定类型并不是一个引用。另外，我们还可以提供一个对立的操作：去除这个引用运算符（前提是类型本身就已经是一个引用）。最后，可以添加或者去除const限定符

//
    // Created by oceanstar on 2021/4/23.
    //
    
    #ifndef UNTITLED_TYPEOP_H
    #define UNTITLED_TYPEOP_H
    
    // primary template
    /**********************************
     * typeop1.hpp:
     **********************************/
    template <typename T>
    class TypeOp {
                    // 基本模板
    public:
        typedef T         ArgT;
        typedef T         BareT;
        typedef T const   ConstT;
        typedef T &       RefT;
        typedef T &       RefBareT;
        typedef T const & RefConstT;
    };
    /**** end of typeop1.hpp ****/
    
    
    // partial specialization for const
    /**********************************
     * typeop2.hpp:
     **********************************/
    template <typename T>
    class TypeOp <T const> {
          // 针对const类型的局部特化
    public:
        typedef T const   ArgT;
        typedef T         BareT;
        typedef T const   ConstT;
        typedef T const & RefT;
        typedef T &       RefBareT;
        typedef T const & RefConstT;
    };
    /**** end of typeop2.hpp ****/
    
    // partial specialization for references
    /**********************************
     * typeop3.hpp:
     **********************************/
    template <typename T>
    class TypeOp <T&> {
               // 针对引用的局部特化
    public:
        typedef T &                         ArgT;
        typedef typename TypeOp<T>::BareT   BareT;
        typedef T const                     ConstT;
        typedef T &                         RefT;
        typedef typename TypeOp<T>::BareT & RefBareT;
        typedef T const &                   RefConstT;
    };
    /**** end of typeop3.hpp ****/
    
    // full specialization for void
    /**********************************
     * typeop4.hpp:
     **********************************/
    template<>
    class TypeOp <void> {
             // 针对void的局部特化
    public:
        typedef void       ArgT;
        typedef void       BareT;
        typedef void const ConstT;
        typedef void       RefT;
        typedef void       RefBareT;
        typedef void       RefConstT;
    };
    /**** end of typeop4.hpp ****/
    #endif //UNTITLED_TYPEOP_H

模板修改为：

#ifndef UNTITLED_APPLY_H
    #define UNTITLED_APPLY_H
    
    #include "typeop.h"
    
    template <typename T>
    void apply (typename TypeOp<T>::RefT arg, void (*func)(T))
    {
        
        func(arg);
    }
    #endif //UNTITLED_APPLY_H

最后，现在已经不能根据第一个实参来演绎参数T了，因为T现在位于一个受限名称中。因此，只能根据第2个实参来演绎T，然后根据演绎出来的结果，来生成第一个参数的实际类型

# promotion trait #

到目前为止，我们已经研究并开发了单一类型的类型函数：即给定一个类型，我们可以定义其他相关的类型或者参数。但是，我们通常都需要开发依赖于多个实参的类型函数。一个典型的例子是`promotion trait`，它在编写运算符模板的时候非常有用。

> promotion的含义是“提升”，指对于两个不同的类型，找到其中一个更加强大的类型；或者对于某个类型，根据需要变成一个更加强大的类型。其中“更加强大”通常是指“size时函数返回的整型值更大”

看个例子：编写一个函数模板，用于对两个Array容器进行相加：

template<typename T>
    Array<T> operator+ (Array<T>const&, Aray<T>const &);

这看起来非常好。但是，由于语言允许我们把一个char类型的值加到一个int值，因此，我们期望可以对数组也实现这种混合类型的操作。于是，我们面临一个问题，即如何确定结果模板的返回类型：

template<typename T1, typename T2>
    Array<???> operator+ (Array<T1> const&, Array<T2>const &);

这时，我们可以借助于promation trait，我们就可以解决上面的问题：

template<typename T1, typename T2>
    Array<typename Promotion<T1, T2>::ResultT>
    operator+ (Array<T1> const&, Array<T2> const&);

或使用如下方式：

template<typename T1, typename T2> 
    typename Promotion<Array<T1>, Array<T2> >::ResultT 
    operator+ (Array<T1> const&, Array<T2> const&);

此种想法在于为 template Promotion 提供大量特化版本，以创建出一个满足我们所需的 type function。另一个应用由 max() template 激发出来：当我们希望指出类型不同的两数值中的较大 者时，应该采用「较大」的那个类型（2个类型中更加强大的类型）

## 实现 ##

> **第一步：声明typename Promotion主模板**

由于template 并不存在真正的泛型定义。最好的选择是：别去定义 primary class template（主模板）：

template<typename T1, typename T2>
    class Promotion;

> **第二步：定义一个具有在2个类型中选择某一个类型方法的模板**

template<bool C, typename Ta, typename Tb>
    class IfThenElse;
    
    //  局部特化: true 的话选择第二个实参
    template<typename Ta, typename Tb>
    class IfThenElse<true, Ta, Tb>{
        
    public:
        typedef Ta ResultT;
    };
    
    // 局部特化: false 的话选择第三个实参
    template<typename Ta, typename Tb>
    class IfThenElse<false, Ta, Tb>{
        
    public:
        typedef Tb ResultT;
    };

> **第三步：定义第一步中声明的模板**（根据所需要提升的类型的大小，在T1， T2， void三者之间做出选择）

template<typename T1, typename T2>
    class Promotion{
        
    public:
        typedef typename  IfThenElse<
                (sizeof(T1)>sizeof(T2)), 
                T1,
                typename IfThenElse<
                        (sizeof(T1)<sizeof(T2)),
                        T2,
                        void>::ResultT
                 >::ResultT resultT;
    };

> **第四步：针对Promotion 进行一些局部特化**

//两个参数相同的局部特化版本
    template<typename T>
    class Promotion<T,T>{
        
    public:
        typedef T ResultT;
    };

> **第五步：针对普通类型的 全特化 版本**

可以利用宏，减少源代码的数量

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

> **第六步：添加一些普通类型的全特化提升**

MK_PROMOTION(bool, char, int)
    MK_PROMOTION(bool, unsigned char, int)
    MK_PROMOTION(bool, signed char, int)
    //...

这种方式相当直截了当，却需要列举数十个可能组合。

> **第七步：为了一般类型提供提升的规则(除了基本类型和枚举类型之外)**

以Array 为例：

template <typename T>
    class Array {
        
    };
    
    template<typename T1, typename T2>
    class Promotion<Array<T1>, Array<T2> > {
        
    public:
        typedef Array<typename Promotion<T1,T2>::ResultT> ResultT;
    };
    
    // //针对array的 2个参数相同的 局部特化版本
    template<typename T>
    class Promotion<Array<T>, Array<T> > {
        
    public:
        typedef Array<typename Promotion<T,T>::ResultT> ResultT;
    };

最后这个偏特化版本有若干特别值得注意的地方。 乍见之下， 好像先前针对类型一致 （identical types）而设计的局部特化版本（Promotion< T,T>）已经处理了这种情况。不幸的是，就特化程度而言，Promotion< T,T>和 Promotion< Array< T1>, Array< T2> > 是一样的。为避免选择 templates 时发生模棱两可（歧义）情况，我们增加了最后一个局部特化版本，它比前面2个局部特化版本更加特殊化。

当更多 types 被加入时，为了使 promotion（类型晋升）有意义，我们需要为 Promotion template 加入更多的全特化版本和局部特化版本。

[20210423130509374.png]: /images/20221022/d05a655d043c49059f32f05b219a8f2a.png
[20210423131054871.png]: /images/20221022/69494237a0234b92a03ba06a797f9ccf.png