编程语言
首页 > 编程语言> > C++模板沉思录

C++模板沉思录

作者:互联网

0 论抽象——前言

故事要从一个看起来非常简单的功能开始:

请计算两个数的和。

如果你对Python很熟悉,你一定会觉得:“哇!这太简单了!”,然后写出以下代码:

def Plus(lhs, rhs):

    return lhs + rhs

那么,C语言又如何呢?你需要面对这样的问题:

/* 这里写什么?*/ Plus(/* 这里写什么?*/ lhs, /* 这里写什么?*/ rhs)
{
    return lhs + rhs;
}

也许你很快就能想到以下解法中的一些或全部:

  1. 硬编码为某个特定类型:
int Plus(int lhs, int rhs)
{
    return lhs + rhs;
}

显然,这不是一个好的方案。因为这样的Plus函数接口强行的要求两个实参以及返回值的类型都必须是int,或是能够发生隐式类型转换到int的类型。此时,如果实参并不是int类型,其结果往往就是错误的。请看以下示例:

int main()
{
    printf("%d\n", Plus(1, 2));          // 3,正确
    printf("%d\n", Plus(1.999, 2.999));  // 仍然是3!
}
  1. 针对不同类型,定义多个函数
int Plusi(int lhs, int rhs)
{
    return lhs + rhs;
}


long Plusl(long lhs, long rhs)
{
    return lhs + rhs;
}


double Plusd(double lhs, double rhs)
{
    return lhs + rhs;
}


// ...

这种方案的缺点也很明显:其使得代码写起来像“汇编语言”(movl,movq,...)。我们需要针对不同的类型调用不同名称的函数(是的,C语言也不支持函数重载),这太可怕了。

  1. 使用宏
#define Plus(lhs, rhs) (lhs + rhs)

这种方案似乎很不错,甚至“代码看上去和Python一样”。但正如许许多多的书籍都讨论过的那样,宏,不仅“抛弃”了类型,甚至“抛弃”了代码。是的,宏不是C语言代码,其只是交付于预处理器执行的“复制粘贴”的标记。一旦预处理完成,宏已然不再存在。可想而知,在功能变得复杂后,宏的缺点将会越来越大:代码晦涩,无法调试,“莫名其妙”的报错...

看到这里,也许你会觉得:“哇!C语言真烂!居然连这么简单的功能都无法实现!”。但请想一想,为什么会出现这些问题呢?让我们回到故事的起点:

请计算两个数的和。

仔细分析这句话:“请计算...的和”,意味着“加法”语义,这在C语言中可以通过“+”实现(也许你会联想到汇编语言中的加法实现);而“两个”,则意味着形参的数量是2(也许你会联想到汇编语言中的ESS、ESP、EBP等寄存器);那么,“数”,意味着什么语义?C语言中,具有“数”这一语义的类型有十几种:int、double、unsigned,等等,甚至char也具有“数”的语义。那么,“加法”和“+”,“两个”和“形参的数量是2”,以及“数”和int、double、unsigned等等之间的关系是什么?

是抽象。

高级语言的目的,就是对比其更加低级的语言进行抽象,从而使得我们能够实现更加高级的功能。抽象,是一种人类的高级思维活动,是一种充满着智慧的思维活动。汇编语言抽象了机器语言,而C语言则进一步抽象了汇编语言:其将汇编语言中的各种加法指令,抽象成了一个简单的加号;将各种寄存器操作,抽象成了形参和实参...抽象思维是如此的普遍与自然,以至于我们往往甚至忽略了这种思维的存在。

但是,C语言并没有针对类型进行抽象的能力,C语言不知道,也没有能力表达“int和double都是数字”这一语义。而这,直接导致了这个“看起来非常简单的功能”难以完美的实现。

针对类型的抽象是如此重要,以至于编程语言世界出现了与C语言这样的“静态类型语言”完全不一样的“动态类型语言”。正如开头所示,在Python这样的动态类型语言中,我们根本就不需要为每个变量提供类型,从而似乎“从根本上解决了问题”。但是,“出来混,迟早要还的”,这种看似完美的动态类型语言,牺牲的却是极大的运行时效率!我们不禁陷入了沉思:真的没有既不损失效率,又能对类型进行抽象的方案了吗?

正当我们一筹莫展,甚至感到些许绝望之时,C++的模板,为我们照亮了前行的道路。

1 新手村——模板基础

1.1 函数模板与类模板

模板,即C++中用以实现泛型编程思想的语法组分。模板是什么?一言以蔽之:类型也可以是“变量”的东西。这样的“东西”,在C++中有二:函数模板和类模板。

通过在普通的函数定义和类定义中前置template <...>,即可定义一个模板,让我们以上文中的Plus函数进行说明。请看以下示例:

此为函数模板:

template <typename T>
T Plus(T lhs, T rhs)
{
    return lhs + rhs;
}


int main()
{
    cout << Plus(1, 2) << endl;          // 3,正确!
    cout << Plus(1.999, 2.999) << endl;  // 4.998,同样正确!
}

此为类模板:

template <typename T>
struct Plus
{
    T operator()(T lhs, T rhs)
    {
        return lhs + rhs;
    }
};


int main()
{
    cout << Plus<int>()(1, 2) << endl;             // 3,正确!
    cout << Plus<double>()(1.999, 2.999) << endl;  // 4.998,同样正确!
}

显然,模板的出现,使得我们轻而易举的就实现了类型抽象,并且没有(像动态类型语言那样)引入任何因为此种抽象带来的额外代价。

1.2 模板形参、模板实参与默认值

请看以下示例:

template <typename T>
struct Plus
{
    T operator()(T lhs, T rhs)
    {
        return lhs + rhs;
    }
};


int main()
{
    cout << Plus<int>()(1, 2) << endl;
    cout << Plus<double>()(1.999, 2.999) << endl;
}

上例中,typename T中的T,称为模板形参;而Plus<int>中的int,则称为模板实参。在这里,模板实参是一个类型。

事实上,模板的形参与实参既可以是类型,也可以是值,甚至可以是“模板的模板”;并且,模板形参也可以具有默认值(就和函数形参一样)。请看以下示例:

template <typename T, int N, template <typename U, typename = allocator<U>> class Container = vector>
class MyArray
{
    Container<T> __data[N];
};


int main()
{
    MyArray<int, 3> _;
}

上例中,我们声明了三个模板参数:

  1. typename T:一个普通的类型参数
  2. int N:一个整型参数
  3. template <typename U, typename = allocator<U>> class Container = vector:一个“模板的模板参数”

什么叫“模板的模板参数”?这里需要明确的是:模板、类型和值,是三个完全不一样的语法组分。模板能够“创造”类型,而类型能够“创造”值。请参考以下示例以进行辨析:

vector<int> v;

此例中,vector是一个模板,vector<int>是一个类型,而v是一个值。

所以,一个“模板的模板参数”,就是一个需要提供给其一个模板作为实参的参数。对于上文中的声明,Container是一个“模板的模板参数”,其需要接受一个模板作为实参 。需要怎样的模板呢?这个模板应具有两个模板形参,且第二形参具有默认值allocator<U>;同时,Container具有默认值vector,这正是一个符合要求的模板。这样,Container在类定义中,便可被当作一个模板使用(就像vector那样)。

1.3 特化与偏特化

模板,代表了一种泛化的语义。显然,既然有泛化语义,就应当有特化语义。特化,使得我们能为某些特定的类型专门提供一份特殊实现,以达到某些目的。

特化分为全特化与偏特化。所谓全特化,即一个“披着空空如也的template <>的普通函数或类”,我们还是以上文中的Plus函数为例:

// 不管T是什么类型,都将使用此定义...
template <typename T>
T Plus(T lhs, T rhs)
{
    return lhs + rhs;
}


// ...但是,当T为int时,将使用此定义
template <>  // 空空如也的template <>
int Plus(int lhs, int rhs)
{
    return lhs + rhs;
}


int main()
{
    Plus(1., 2.);  // 使用泛型版本
    Plus(1, 2);    // 使用特化版本
}

那么,偏特化又是什么呢?除了全特化以外的特化,都称为偏特化。这句话虽然简短,但意味深长,让我们来仔细分析一下:首先,“除了全特化以外的...”,代表了template关键词之后的“<>”不能为空,否则就是全特化,这显而易见;其次,“...的特化”,代表了偏特化也必须是一个特化。什么叫“是一个特化”呢?只要特化版本比泛型版本更特殊,那么此版本就是一个特化版本。请看以下示例:

// 泛化版本
template <typename T, typename U>
struct _ {};


// 这个版本的特殊之处在于:仅当两个类型一样的时候,才会且一定会使用此版本
template <typename T>
struct _<T, T> {};


// 这个版本的特殊之处在于:仅当两个类型都是指针的时候,才会且一定会使用此版本
template <typename T, typename U>
struct _<T *, U *> {};


// 这个版本“换汤不换药”,没有任何特别之处,所以不是一个特化,而是错误的重复定义
template <typename A, typename B>
struct _<A, B> {};

由此可见,“更特殊”是一个十分宽泛的语义,这赋予了模板极大的表意能力,我们将在下面的章节中不断的见到特化所带来的各种技巧。

1.4 惰性实例化

函数模板不是函数,而是一个可以生成函数的语法组分;同理,类模板也不是类,而是一个可以生成类的语法组分。我们称通过函数模板生成函数,或通过类模板生成类的过程为模板实例化。

模板实例化具有一个非常重要的特征:惰性。这种惰性主要体现在类模板上。请看以下示例:

template <typename T>
struct Test
{
    void Plus(const T &val)  { val + val; }
    void Minus(const T &val) { val - val; }
};


int main()
{
    Test<string>().Plus("abc");
    Test<int>().Minus(0);
}

上例中,Minus函数显然是不适用于string类型的。也就是说,Test类对于string类型而言,并不是“100%完美的”。当遇到这种情况时,C++的做法十分宽松:不完美?不要紧,只要不调用那些“不完美的函数”就行了。在编译器层面,编译器只会实例化真的被使用的函数,并对其进行语法检查,而根本不会在意那些根本没有被用到的函数。也就是说,在上例中,编译器实际上只实例化出了两个函数:string版本的Plus,以及int版本的Minus。

在这里,“懒惰即美德”占了上风。

1.5 依赖型名称

在C++中,“::”表达“取得”语义。显然,“::”既可以取得一个值,也可以取得一个类型。这在非模板场景下是没有任何问题的,并不会引起接下来即将将要讨论的“取得的是一个类型还是一个值”的语义混淆,因为编译器知道“::”左边的语法组分的定义。但在模板中,如果“::”左边的语法组分并不是一个确切类型,而是一个模板参数的话,语义将不再是确定的。请看以下示例:

struct A { typedef int TypeOrValue; };
struct B { static constexpr int TypeOrValue = 0; };


template <typename T>
struct C
{
    T::TypeOrValue;  // 这是什么?
};

上例中,如果T是A,则T::TypeOrValue是一个类型;而如果T是B,则T::TypeOrValue是一个数。我们称这种含有模板参数的,无法立即确定语义的名称为“依赖型名称”。所谓“依赖”,意即此名称的确切语义依赖于模板参数的实际类型。

对于依赖型名称,C++规定:默认情况下,编译器应认为依赖型名称不是一个类型;如果需要编译器将依赖型名称视为一个类型,则需要前置typename关键词。请看以下示例以进行辨析:

T::TypeOrValue * N;           // T::TypeOrValue是一个值,这是一个乘法表达式
typename T::TypeOrValue * N;  // typename T::TypeOrValue是一个类型,声明了一个这样类型的指针

1.6 可变参数模板

可变参数模板是C++11引入的一个极为重要的语法。这里对其进行简要介绍。

可变参数模板表达了“参数数量,以及每个参数的类型都未知且各不相同”这一语义。如果我们希望实现一个简单的print函数,其能够传入任意数量,且类型互不相同的参数,并依次打印这些参数值,此时就需要使用可变参数模板。

可变参数模板的语法由以下组分构成:

  1. typename...:声明一个可变参数模板形参
  2. sizeof...:获取参数包内参数的数量
  3. Pattern...:以某一模式展开参数包

接下来,我们就基于可变参数模板,实现这一print函数。请看以下示例:

// 递归终点
void print() {}


// 分解出一个val + 剩下的所有val
// 相当于:void print(const T &val, const Types1 &Args1, const Types2 &Args2, const Types3 &Args3, ...)
template <typename T, typename... Types>
void print(const T &val, const Types &... Args)
{
    // 每次打印一个val
    cout << val << endl;

    // 相当于:print(Args1, Args2, Args3, ...);
    // 递归地继续分解...
    print(Args...);
}


int main()
{
    print(1, 2., '3', "4");
}

上例中,我们实现了一对重载的print函数。第一个print函数是一个空函数,其将在“Args...”是空的时候被调用,以作为递归终点;而第二个print函数接受一个val以及余下的所有val作为参数,其将打印val,并使用余下的所有val继续递归调用自己。不难发现,第二版本的print函数具有不断打印并分解Args的能力,直到Args被完全分解。

2 平淡无奇却暗藏玄机的语法——sizeof与SFINAE

2.1 sizeof

“sizeof?这有什么可讨论的?”也许你会想。只要你学过C语言,那么对此必不陌生。那么为什么我们还需要为sizeof这一“平淡无奇”的语法单独安排一节来讨论呢?这是因为sizeof有两个对于泛型编程而言极为重要的特性:

  1. sizeof的求值结果是编译期常量(从而可以作为模板实参使用)
  2. 在任何情况下,sizeof都不会引发对其参数的求值或类似行为(如函数调用,甚至函数定义!等),因为并不需要

上述第一点很好理解,因为sizeof所考察的是类型,而类型(当然也包含其所占用的内存大小),一定是一个编译期就知道的量(因为C++作为一门静态类型语言,任何的类型都绝不会延迟到运行时才知道,这是动态类型语言才具有的特性),故sizeof的结果是一个编译期常量也就不足为奇了。

上述第二点意味深长。利用此特性,我们可以实现出一些非常特殊的功能。请看下一节。

2.2 稻草人函数

让我们以一个问题引出这一节的内容:

如何实现:判定类型A是否能够基于隐式类型转换转为B类型?

乍看之下,这是个十分棘手的问题。此时我们应当思考的是:如何引导(请注意“引导”一词的含义)编译器,在A到B的隐式类型转换可行时,走第一条路,否则,走第二条路?

请看以下示例:

template <typename A, typename B>
class IsCastable
{
private:

    // 定义两个内存大小不一样的类型,作为“布尔值”
    typedef char __True;
    typedef struct { char _[2]; } __False;


    // 稻草人函数
    static A __A();


    // 只要A到B的隐式类型转换可用,重载确定的结果就是此函数...
    static __True __Test(B);


    // ...否则,重载确定的结果才是此函数(“...”参数的重载确定优先级低于其他一切可行的重载版本)
    static __False __Test(...);


public:

    // 根据重载确定的结果,就能够判定出隐式类型转换是否能够发生
    static constexpr bool Value = sizeof(__Test(__A())) == sizeof(__True);
};

上例比较复杂,我们依次进行讨论。

首先,我们声明了两个大小不同的类型,作为假想的“布尔值”。也许你会有疑问,这里为什么不使用int或double之类的类型作为False?这是由于C语言并未规定“int、double必须比char大”,故为了“强行满足标准”(你完全可以认为这是某种“教条主义或形式主义”),这里采用了“两个char一定比一个char大一倍”这一简单道理,定义了False。

然后,我们声明了一个所谓的“稻草人函数”,这个看似毫无意义的函数甚至没有函数体(因为并不需要,且接下来的两个函数也没有函数体,与此函数同理)。这个函数唯一的目的就是“获得”一个A类型的值“给sizeof看”。由于sizeof的不求值特性,此函数也就不需要(我们也无法提供)函数体了。那么,为什么不直接使用形如“T()”这样的写法,而需要声明一个“稻草人函数”呢?我想,不用我说你就已经明白原因了:这是因为并不是所有的T都具有默认构造函数,而如果T没有默认构造函数,那么“T()”就是错误的。

接下来是最关键的部分,我们声明了一对重载函数,这两个函数的区别有二:

  1. 返回值不同,一个是sizeof的结果为1的值,而另一个是sizeof的结果为2的值
  2. 形参不同,一个是B,一个是“...”

也就是说,如果我们给这一对重载函数传入一个A类型的值时,由于“...”参数的重载确定优先级低于其他一切可行的重载版本,只要A到B的隐式类型转换能够发生,重载确定的结果就一定是调用第一个版本的函数,返回值为__True;否则,只有当A到B的隐式类型转换真的不可行时,编译器才会“被迫”选择那个编译器“最不喜欢的版本”,从而使得返回值为__False。返回值的不同,就能够直接体现在sizeof的结果不同上。所以,只需要判定sizeof(__Test(__A()))是多少,就能够达到我们最终的目的了。下面请看使用示例:

int main()
{
    cout << IsCastable<int, double>::Value << endl;  // true
    cout << IsCastable<int, string>::Value << endl;  // false
}

可以看出,输出结果完全符合我们的预期。

2.3 SFINAE

SFINAE(Substitution Failure Is Not An Error,替换失败并非错误)是一个高级模板技巧。首先,让我们来分析这一拗口的词语:“替换失败并非错误”。

什么是“替换”?这里的替换,实际上指的正是模板实例化;也就是说,当模板实例化失败时,编译器并不认为这是一个错误。这句话看上去似乎莫名其妙,也许你会有疑问:那怎么样才认为是一个错误?我们又为什么要讨论一个“错误的东西”呢?让我们以一个问题引出这一技巧的意义:

如何判定一个类型是否是一个类类型?

“哇!这个问题似乎比上一个问题更难啊!”也许你会这么想。不过有了上一个问题的铺垫,这里我们依然要思考的是:一个类类型,有什么独一无二的东西是非类类型所没有的?(这样我们似乎就能让编译器在“喜欢和不喜欢”之间做出抉择)

也许你将恍然大悟:类的成员指针。

请看以下示例:

template <typename T>
class IsClass
{
private:

    // 定义两个内存大小不一样的类型,作为“布尔值”
    typedef char __True;
    typedef struct { char _[2]; } __False;


    // 仅当T是一个类类型时,“int T::*”才是存在的,从而这个泛型函数的实例化才是可行的
    // 否则,就将触发SFINAE
    template <typename U>
    static __True __Test(int U::*);


    // 仅当触发SFINAE时,编译器才会“被迫”选择这个版本
    template <typename U>
    static __False __Test(...);


public:

    // 根据重载确定的结果,就能够判定出T是否为类类型
    static constexpr bool Value = sizeof(__Test<T>(0)) == sizeof(__True);
};

同样,我们首先定义了两个内存大小一定不一样的类型,作为假想的“布尔值”。然后,我们声明了两个重载模板,其分别以两个“布尔值”作为返回值。这里的关键在于,重载模板的参数,一个是类成员指针,另一个是“...”。显然,当编译器拿到一个T,并准备生成一个“T:

标签:__,const,rhs,C++,lhs,template,沉思,Expression,模板
来源: https://www.cnblogs.com/yingyulou/p/14410585.html