学习-＞C++篇五：模板与STL简介

目录

1. 函数模板

2. 类模板

3.模板的语法

（1）非类型模板参数

（2)   模板的特化

（3）模板的分离编译

4.STL简介

---

1. 函数模板

模板是泛型编程的基础，一个模板就是一个创建类或函数的蓝图或者说公式。

例如：要定义一个比较函数，在实际中可能要定义多个函数，每个函数比较一种类型的值。

int compare(const string&s1,const string&s2)
{
    if(s1<s2)return -1;
    if(s1>s2)return 1;
    return 0;
}

int compare(const double&s1,const double&s2)
{
    if(s1<s2)return -1;
    if(s1>s2)return 1;
    return 0;
}

这两个函数参数类型不同，函数体是相同的，如果针对不同类型都要重载相应函数，这样就繁琐且代码复用性差,而且代码可维护性差。于是可以定义一个通用的函数模板，用来生成特定类型的函数版本。

模板定义以关键字template开始，后跟模板参数列表（用逗号分割的一至多个模板参数列表），用<>包围：

template<typename T>
int compare(const T&v1,const T&v2)
{
    if(v1<v2)return -1;
    if(v1>v2)return 1;
    return 0;
}

其中typename是模板类型参数，也可以用class（二者含义相同）

实例化函数模板：

当我们调用一个函数模板时，编译器在编译期用函数实参来为我们推断模板的实参，编译器用推断出的模板实参生成特定版本的函数称为实例化。

例如：

上面四个调用，因为类型不同，编译器便实例化出了四个不同的函数版本。

从反汇编可看出，调用了四个不同类型实参的函数：

 注意：string的类型是：

basic_string<char,char_traits<char>,allocator<char>>

 因为string是basic_string类模板的一个实例：

2. 类模板

要定义适用于不同数据类型的类，可以用类模板。

格式如：

template < class T1 , class T2 , ..., class Tn >

class 类模板名

{

        // 类内成员定义

};

例如，要写一个vector用于存储各种数据的类模板：

namespace myspace {
    template <class T>
    class vector
    {
    private:
        T* _data;
        int _capacity;
        int _size;

    public:
        vector()
            :_data(new T[10])
            ,_capacity(10)
            ,_size(0)
        {}

        ~vector()
        {
            if (_data)
                delete[]_data;
            _size = _capacity = 0;
        }

        void push_back(const T& data);
        //...
    };

    template<class T>//若要在类外定义函数，需加上模板参数列表
    void vector<T>::push_back(const T& data)
    {
        //...
        _data[_size++] = data;
    }

}

using namespace myspace;

int main()
{
    //根据不同类型，编译器生成不同类型的类，称为类模板的实例化，
    //vector是类模板名字，vector<int>才是类型的名字
    vector<int>vi;
    vector<double>vd;
    return 0;
}

3.模板的语法

（1）非类型模板参数

模板参数分为：

类型模板参数：出现在模板参数列表中，跟在class或typename关键字后的名称

例如：template<class T>class vector;中的T

非类型模板参数： 出现在模板参数列表中，用特定类型名而非class或template关键字修饰，当模板被实例化时，非类型参数被用户提供的或编译器推断出的值替代，这些值必须是常量表达式。

例如：template<class T, size_t N = 10> class array ；

 注意：

1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的（可以是：整形（常量表达式），指针/左值引用（static对象或常量表达式））。

2. 非类型的模板参数必须在编译期就能确认结果。 

（2)   模板的特化

在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。

例如：实现一个比较大小的函数模板

如上：当比较pa和pb时，返回的是false，原因是比较的是pa和pb地址的大小，pb的地址更小。

若要在比较指针时比较的是指针指向的内容，便可以用函数模板特化。

格式：template加<>,空<>表示将为所有模板参数提供实参，函数实参的类型必须与先前声明的模板中对应的类型匹配，比如原先const修饰的是v1，v2,改成指针类型时也得修饰指针本身，而不是修饰指针指向的内容。

如：

template <typename T>
bool Greater(const T& v1, const T& v2)
{
	return v1 > v2;
}

//template <>
//bool Greater( const int*&p1,  const int*&p2)//error,参数类型不匹配
//{
//	return *p1 > *p2;
//}

template <>
bool Greater( int* const &p1,  int* const &p2)
{
	return *p1 > *p2;
}

//或者：
//template <>
//bool Greater(const int* const& p1, const int* const& p2)
//{
//	return *p1 > *p2;
//}

//或者：函数名后跟<>,<>中指定需要特化的类型
//template <>
//bool Greater<int*>(int* const& p1, int* const& p2)
//{
//	return *p1 > *p2;
//}
int main()
{
	int a = 20;
	int b = 10;
	if (Greater(a, b))
		cout << "a is greater than b." << endl;
	int* pa = &a;
	int* pb = &b;

	if (Greater(pa, pb))
		cout << "pa->a is greater than pb->b." << endl;
	return 0;
}

结果：

 函数模板特化的本质是实例化一个模板，而不是重载它，如果将上述函数再定义一个普通的非模板函数，参数类型等都匹配时，调用时编译器会选择非模板函数，一般直接给出非模板函数更方便，不用考虑模板参数类型匹配。

（3）模板的分离编译

        将若干个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译。 所谓模板的分离编译，就是将其定义与声明分离，与内联函数相似，会产生链接错误。解决方法就是不这么干，或者在其定义的地方显式实例化。

例如：在.cpp中定义，在.h中声明，在另一个.cpp中使用，产生了链接错误

 

 解决方法一：直接在.h定义

 解决方法二：在定义的位置实例化（失去了模板的灵魂了）

 

 

        总结：模板让代码复用性增强，增加了开发速度，也同时催生了STL的诞生。但是因为模板每次实例化都要产生一份代码，所以代码量是增加很多的，会导致编译时间增加。模板报错时往往报错信息也复杂，不容易定位错误信息。

4.STL简介

        STL(standard template libaray-标准模板库)：是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。

        最早的版本是由惠普实验室完成的HP版本，是各个版本的始祖，HP版本开源后，出现了各种版本，如：

PJ版本：由P. J. Plauger开发，继承自HP版本，被Windows Visual C++采用，不能公开或修改，缺陷：可读性比较低，符号命名怪异。

SGI 版本：由Silicon Graphics Computer Systems ， Inc 公司开发，继承自 HP 版 本。被 GCC(Linux) 采用，可移植性好，可公开、修改甚至贩卖，从命名风格和编程 风格上看，阅读性非常高。

STL由；六大组件构成，是算法，容器，仿函数，迭代器，空间配置器，配接器（容器适配器）

STL缺点：

STL还未支持线程安全。并发环境下需要我们自己加锁。且锁的粒度是比较大的。

STL极度的追求效率，导致内部比较复杂。比如类型萃取，迭代器萃取。

 STL的使用会有代码膨胀的问题，比如使用vector<int>/vector<double>/vector<char>这样会生成多份代码，这是模板语法本身导致的(将代码交给编译器生成）。