元模板 笔记

对类型编写,由于c++不存在

if(type == xxx) {}

这种语法。

类型计算可以使用:

1,重载。

2,虚函数。继承。

3,c语言中利用 Union

查看代码
struct Variant
{
    union
    {
        int x;
        float y;
    } data;
    uint32 typeId;
};

Variant addFloatOrMulInt(Variant const* a, Variant const* b)
{
    Variant ret;
    assert(a->typeId == b->typeId);
    if (a->typeId == TYPE_INT)
    {
        ret.x = a->x * b->x;
    }
    else
    {
        ret.y = a->y + b->y;
    }
    return ret;
}

4,void*

查看代码
 #define BIN_OP(type, a, op, b, result) (*(type *)(result)) = (*(type const *)(a)) op (*(type const*)(b))
void doDiv(void* out, void const* data0, void const* data1, DATA_TYPE type)
{
    if(type == TYPE_INT)
    {
        BIN_OP(int, data0, *, data1, out);
    }
    else
    {
        BIN_OP(float, data0, +, data1, out);
    }
}

5,C++中比如在 Boost.Any 的实现中,运用了 typeid 来查询类型信息。

6,和 typeid 同属于RTTI机制的 dynamic_cast,也经常会用来做类型判别的工作。

查看代码
 IAnimal* animal = GetAnimalFromSystem();

IDog* maybeDog = dynamic_cast<IDog*>(animal);
if(maybeDog)
{
    maybeDog->Wangwang();
}
ICat* maybeCat = dynamic_cast<ICat*>(animal);
if(maybeCat)
{
    maybeCat->Moemoe();
}

用模板后

在模板代码中,这个“合适的机制”就是指“特化”和“部分特化(Partial Specialization)”,后者也叫“偏特化”。

特化:

// 我们这个模板的基本形式是什么?
template <typename T> class AddFloatOrMulInt;

// 但是这个类,是给T是Int的时候用的,于是我们写作
class AddFloatOrMulInt<int>
// 当然,这里编译是通不过的。

// 但是它又不是个普通类,而是类模板的一个特化(特例)。
// 所以前面要加模板关键字template,
// 以及模板参数列表
template </* 这里要填什么? */> class AddFloatOrMulInt<int>;

// 最后,模板参数列表里面填什么?因为原型的T已经被int取代了。所以这里就不能也不需要放任何额外的参数了。
// 所以这里放空。
template <> class AddFloatOrMulInt<int>
{
    // ... 针对Int的实现 ... 
}

// Bingo!

 

类型参数相当于函数的参数,里面的定义的成员值,相当于返回值。定义多个成员,意味着可以返回多个值了!!

//对于一般没匹配特例的,参数是T,类型函数返回值是 -2.
template <typename T> class TypeToID
{
public:
    static int const NotID = -2;
};
//对于float参数,返回值是1。注意取值时,可以自己写了 ID. 而上面用的是 NotID
template <> class TypeToID<float>
{
public:
    static int const ID = 1;
};

类模板和类模板的特化的作用,仅仅是指导编译器选择哪个编译,但是特化之间、特化和它原型的类模板之间,是分别独立实现的。所以如果多个特化、或者特化和对应的类模板有着类似的内容,很不好意思,你得写上若干遍了。

重载与模板

重载:

void doWork(int);
void doWork(float);
void doWork(int, int);

void f() {
    doWork(0);
    doWork(0.5f);
    doWork(0, 0);
}

对应模板

template <typename T> struct DoWork;     // (0) 这是原型 相当于函数,即申明了 只有一个类型参数的 函数。

//上面相当于申明函数f(T), T是一个类型。不普通函数的值。那么f(int),f(float)都行。f(int,int)多了个参数,肯定不行了。
template <> struct DoWork<int> {};       // (1) 这是 int 类型的"重载"
template <> struct DoWork<float> {};     // (2) 这是 float 类型的"重载"
template <> struct DoWork<int, int> {};  // (3) 这是 int, int 类型的“重载”

void f(){
    DoWork<int>      i;
    DoWork<float>    f;
    DoWork<int, int> ii;
}

 所以DoWork<int, int>会导致编译错误,实参和原型不对应啊。因为原型里面只有一个参数 T。<int,int>是两个参数。

 

练习:

#include <memory>

using std::unique_ptr;
using std::shared_ptr;

template <typename T, typename U> struct X            ;    // #0 原型有两个类型参数
                                                           // 所以下面的这些偏特化的实参列表
                                                           // 也需要两个类型参数对应

// 下面的这些偏特化的“小尾巴”也需要两个类型参数对应
template <typename T>             struct X<T,  T  > {};    // 1
template <typename T>             struct X<T*, T  > {};    // 2
template <typename T>             struct X<T,  T* > {};    // 3
template <typename U>             struct X<U,  int> {};    // 4
template <typename U>             struct X<U*, int> {};    // 5
template <typename U, typename T> struct X<U*, T* > {};    // 6
template <typename U, typename T> struct X<U,  T* > {};    // 7

template <typename T>             struct X<unique_ptr<T>, shared_ptr<T>>; // 8


// 以下特化,分别对应哪个偏特化的实例?
// 此时偏特化中的T或U分别是什么类型?

X<float*,  int>      v0;           //5   第二个是整型,先看偏特化第二个参数是整型的。再看第一个是指针。         
X<double*, int>      v1;           //5         
X<double,  double>   v2;             //1 第二个参数没有double的。再看两个参数是一个类型的。             
X<float*,  double*>  v3;               //6   两个参数不一样,但是都是指针的。         
// X<float*,  float*>   v4;            //两个参数都一样,并且是指针的。否则还得去指针。编译器不这么认为,报错!!!             
X<double,  float*>   v5;   //7                       
X<int,     double*>  v6;       //7                    
//X<int*,    int>      v7;                       
X<double*, double>   v8; //2

在上面这段例子中,有几个值得注意之处。首先,偏特化时的模板形参,和原型的模板形参没有任何关系

和原型不同,它的顺序完全不影响模式匹配的顺序,它只是偏特化模式,<U, int>U的声明真正的模式,是由<U, int>体现出来的

这也是为什么在特化的时候,当所有类型都已经确定,我们就可以抛弃全部的模板参数,写出template <> struct X<int, float>这样的形式:因为所有列表中所有参数都确定了,就不需要额外的形式参数了。

其次,作为一个模式匹配,偏特化的实参列表中展现出来的“样子”,就是它能被匹配的原因。比如,struct X<T, T>中,要求模板的两个参数必须是相同的类型。而struct X<T, T*>,则代表第二个模板类型参数必须是第一个模板类型参数的指针,比如X<float***, float****>就能匹配上。当然,除了简单的指针、constvolatile修饰符,其他的类模板也可以作为偏特化时的“模式”出现,例如示例8,它要求传入同一个类型的unique_ptrshared_ptr。C++标准中指出下列模式都是可以被匹配的:

N3337, 14.8.2.5/8

T是模板类型实参或者类型列表(如 int, float, double 这样的,TT是template-template实参(参见6.2节),i是模板的非类型参数(整数、指针等),则以下形式的形参都会参与匹配:

T,cv-list T,T*template-name <T>T&T&&

T [ integer-constant ]

type (T)T()T(T)

T type ::*type T::*T T::*

T (type ::*)()type (T::*)()type (type ::*)(T)type (T::*)(T)T (type ::*)(T)T (T::*)()T (T::*)(T)

type [i]template-name <i>TT<T>TT<i>TT<>

对于某些实例化,偏特化的选择并不是唯一的。比如v4的参数是<float*, float*>,能够匹配的就有三条规则,1,6和7。很显然,6还是比7好一些,因为能多匹配一个指针。但是1和6,就很难说清楚谁更好了。一个说明了两者类型相同;另外一个则说明了两者都是指针。所以在这里,编译器也没办法决定使用那个,只好爆出了编译器错误。

其他的示例可以先自己推测一下, 再去编译器上尝试一番:goo.gl/9UVzje

 

非要用重载:

DoWork<int,   void> i;
DoWork<float, void> f;
DoWork<int,   int > ii;

这时,我们就能写出统一的模板原型:

template <typename T0, typename T1> struct DoWork;

继而偏特化/特化问题也解决了:

template <> struct DoWork<int,   void> {};  // (1) 这是 int 类型的特化
template <> struct DoWork<float, void> {};  // (2) 这是 float 类型的特化
template <> struct DoWork<int,    int> {};  // (3) 这是 int, int 类型的特化

 

用默认模板参数,解决不停的写void的问题

template <typename T0, typename T1 = void> struct DoWork;

template <typename T> struct DoWork<T> {}; #0
template <>           struct DoWork<int> {};#1
template <>           struct DoWork<float> {};#2
template <>           struct DoWork<int, int> {};#3

DoWork<int> i; #1
DoWork<float> f; #2
DoWork<double> d;#0
DoWork<int, int> ii;#3

终极用变长模板参数

template <typename... Ts, typename U> class X {};              // (1) error!
template <typename... Ts>             class Y {};              // (2)
template <typename... Ts, typename U> class Y<U, Ts...> {};    // (3)
template <typename... Ts, typename U> class Y<Ts..., U> {};    // (4) error!

为什么第(1)条语句会出错呢?(1)是模板原型,模板实例化时,要以它为基础和实例化时的类型实参相匹配。因为C++的模板是自左向右匹配的,所以不定长参数只能结尾。其他形式,无论写作Ts, U,或者是Ts, V, Us,,或者是V, Ts, Us都是不可取的。(4) 也存在同样的问题。

但是,为什么(3)中, 模板参数和(1)相同,都是typename... Ts, typename U,但是编译器却并没有报错呢?

答案在这一节的早些时候。(3)和(1)不同,它并不是模板的原型,它只是Y的一个偏特化。回顾我们在之前所提到的,偏特化时,模板参数列表并不代表匹配顺序,它们只是为偏特化的模式提供的声明,也就是说,它们的匹配顺序,只是按照<U, Ts...>来,而之前的参数只是告诉你Ts是一个类型列表,而U是一个类型,排名不分先后

 


template <>
class lazy_string_concat_helper<>

template <typename... Strings>
class lazy_string_concat_helper;


template <typename LastString, typename... Strings>
class lazy_string_concat_helper<LastString,
                                Strings...>

lazy_string_concat_helper<std::string> 将被匹配成:lazy_string_concat_helper<std::string>

最具体的是匹配到了第3个:

template <typename LastString, typename... Strings>
class lazy_string_concat_helper<LastString,
                                Strings...> 

最终的特例化是:

template <>  class lazy_string_concat_helper<typename std::string >;

即特例化成:

template<>
class lazy_string_concat_helper<std::string >{

public: 
  inline lazy_string_concat_helper(std::basic_string<char> data, lazy_string_concat_helper<> tail)
  : data{std::basic_string<char>(data)}
  , tail{lazy_string_concat_helper<>(tail)}
  {
  }

}

 

posted @ 2022-10-04 11:40  Bigben  阅读(58)  评论(0编辑  收藏  举报