C++ Primer 学习笔记_76_模板与泛型编程 --模板定义[续]

模板与泛型编程

--模板定义[续]

四、模板类型形參

类型形參由keywordclass或 typename后接说明符构成。在模板形參表中,这两个keyword具有同样的含义,都指出后面所接的名字表示一个类型。

模板类型形參可作为类型说明符在模板中的不论什么地方,与内置类型说明符或类类型说明符的使用方式全然同样。详细而言,它能够用于指定返回类型或函数形參类型,以及在函数体中用于变量声明或强制类型转换。

template <class T>
T calc(const T &a,const T &b)
{
    T tmp = a;
    //...
    return tmp;
}

1、typename与class的差别

在函数模板形參表中,keywordtypename和 class具有同样含义,能够互换使用,两个keyword都能够在同一模板形參表中使用：

template <typename T, class U> calc (const T&, const U&);

使用keywordtypename取代keywordclass指定模板类型形參或许更为直观,毕竟,能够使用内置类型(非类类型)作为实际的类型形參,并且,typename更清楚地指明后面的名字是一个类型名。可是,keywordtypename是作为标准C++的组成部分添加到C++中的,因此旧的程序更有可能仅仅用keywordclass。

2、在模板定义内部指定类型

除了定义数据成员或成员函数外，类还能够定义类型成员。比如,标准库的容器类定义了不同的类型,如size_type,使我们能够以独立于机器的方式使用容器。假设要在函数模板内部使用这种类型,必须告诉编译器我们正在使用的名字指的是一个类型。必须显式地这样做,由于编译器(以及程序的读者)不能通过检查得知,由类型形參定义的名字何时是一个类型何时是一个值。比如,考虑以下的函数:

template <class Parm,class U>
Parm fcn(Parm *array,U value)
{
    Parm: :size_type *p;    	//假设Parm::size_type是一个类型，则该语句是一个声明
                            		//假设Parm::size_type是一个对象，则该语句是一个乘法运算
}

默认情况下,编译器假定这种名字指定数据成员,而不是类型。

假设希望编译器将size_type当作类型,则必须显式告诉编译器这样做:

template <class Parm,class U>
Parm fcn(Parm *array,U value)
{
    typename Parm::size_type *p;   //OK
}

通过在成员名前面加上typename作为前缀，能够告诉编译器将成员当做类型。通过编写typenameparm::size_type,指出绑定到Parm的类型的size_type成员是类型的名字。当然,这一声明给用实例化fcn的类型添加了一个职责:那些类型必须具有名为size_type的成员,并且该成员是一个类型。

【最佳实践】

假设拿不准是否须要以typename指明一个名字是一个类型,那么指定它是个好主意。在类型之前指定typename没有害处,因此,即使typename是不必要的,也没有关系。

//P533 习题16.12
template <typename IterType>
typename IterType::value_type
mostApr(IterType first,IterType last)
{
    map<typename IterType::value_type,size_t> count;
 
    while (first != last)
    {
        ++ count[*first];
 
        ++first;
    }
 
    int apper = 0;
    typename IterType::value_type maxAprItem;
 
    for (typename map<typename IterType::value_type,size_t>::iterator
            iter = count.begin();
            iter != count.end(); ++iter)
    {
        if (iter -> second > apper)
        {
            maxAprItem = iter -> first;
            apper = iter -> second;
        }
    }
 
    return maxAprItem;
}
 
int main()
{
    vector<int> ivec;
    int val;
 
    ifstream inFile("input");
    while (inFile >> val)
    {
        ivec.push_back(val);
    }
 
    cout << mostApr(ivec.begin(),ivec.end()) << endl;
}

//习题16.13
template <typename ContainerType>
void printCntanr(ContainerType contnr)
{
    typename ContainerType::size_type n = 0;
 
    while (n != contnr.size())
    {
        cout << contnr[n ++] << endl;
    }
}

//习题16.14
template <typename IterType>
void printCntanr(IterType first,IterType last)
{
    while (first != last)
    {
        cout << *first << endl;
        ++first;
    }
}

五、非类型模板形參

模板形參不必都是类型。

在调用函数时非类型形參将用值取代，值的类型在模板形參表中指定。

template <class T,size_t N>
void array_init(T (&parm)[N])
{
    for (size_t i = 0; i != N; ++i)
    {
        parm[i] = 0;
    }
}

模板非类型形參是模板定义内部的常量值，在须要常量表达式的时候，可使用非类型形參指定数组的长度。

当调用array_init时，编译器从数组实參计算非类型形參的值：

    int x[42];
    double y[10];
 
    array_init(x);	//T被int替代，N被42替代
    array_init(y);	//T被double替代，N被10替代

编译器将为array_init调用中用到的每种数组实例化一个array_init版本号。

类型等价性与非类型形參

对模板的非类型形參而言，求值结果同样的表达式将觉得是等价的。比方以下的两个array_init调用引用的是同样的实例– array_init<int,42>：

    int x[42];
    const int sz = 40;
    int y[sz + 2];
 
    //两个的函数实例同样
    array_init(x);
    array_init(y);

//P534 习题16.15/16
template <typename Type,std::size_t N>
std::size_t getArrSize(Type (&arr)[N])
{
    return N;
}
 
template <typename ArrType,std::size_t N>
void printArr(ArrType (&arr)[N])
{
    for (std::size_t i = 0; i != N; ++ i)
    {
        cout << arr[i] << endl;
    }
}
 
int main()
{
    int X[] = {3,34,5,65,67,7,7};
    cout << "array size is: " << getArrSize(X) << endl;
    cout << "array items:" << endl;
    printArr(X);
}

六、编写泛型程序

编写模板时,代码不可能针对特定类型,但模板代码总是要对将使用的类型做一些假设。比如,尽管compare函数从技术上说随意类型都是有效的,但实际上,实例化的版本号可能是非法的。

产生的程序是否合法，取决于函数中使用的操作以及所用类型支持的操作：

    if (v1 < v2)
        return -1; // T类型的对象必须支持 <
    if (v1 > v2)
        return 1; // T类型的对象必须支持 >

假设用不支持<操作符的对象调用compare，则调用是无效的：

    Sales_item item1, item2;
    cout << compare(item1, item2) << endl;  //Error：该程序不能编译

【小心地雷】

在函数模板内部完毕的操作限制了可用于实例化该函数的类型。程序猿的责任是：保证用作函数实參的类型实际上支持所用的随意操作，以及保证在模板使用那些操作的环境中那些操作执行正常！

编写独立于类型的代码

【最佳实践】

编写模板代码时，对实參类型的要求尽可能少是非常故意的。

尽管简单，但它说明了编写泛型代码的两个重要原则：

1）模板的形參是const引用

2）函数体中的測试仅仅用<比較

通过将形參设为const引用,就能够同意使用不同意复制的类型。并且,假设有比較大的对象调用compare,则这个设计还能够使函数执行得更快。

比較以下两段程序：

template <typename Type>
int compare(const Type &val1,const Type &val2)
{
    if (val1 < val2)
        return -1;
    else if (val1 > val2)
        return 1;
 
    return 0;
}

与：

template <typename Type>
int compare(const Type &val1,const Type &val2)
{
    if (val1 < val2)
        return -1;
    else if (val2 < val1)
        return 1;
 
    return 0;
}

以下的程序能够降低对可用于compare函数的类型的要求，这些类型必须支持<,但不必支持>

【警告：链接时的编译时错误】

一般而言,编译模板时,编译器可能会在三个阶段中标识错误:

第一阶段是编译模板定义本身时。在这个阶段中编译器一般不能发现很多错误,能够检測到诸如漏掉分号或变量名拼写错误一类的语法错误。

第二个错误检測时间是在编译器见到模板的使用时。在这个阶段,编译器仍没有非常多检查可做。对于函数模板的调用,很多编译器仅仅检查实參的数目和类型是否恰当,编译器能够检測到实參太多或太少,也能够检測到假定类型同样的两个实參是否真地类型同样。对于类模板,编译器能够检測提供的模板实參的正确数目。

产生错误的第三个时间是在实例化的时候,仅仅有在这个时候能够发现类型相关的错误。依据编译器管理实例化的方式,有可能在链接时报告这些错误。

重要的是,要认识到编译模板定义的时候,对程序是否有效所知不多。相似地,甚至可能会在已经成功编译了使用模板的每一个文件之后出现编译错误。仅仅在实例化期间检測错误的情况非常少,错误检測可能发生在链接时。