C++中模板和STL介绍详解

编辑: admin 分类: c#语言 发布时间: 2022-03-15 来源:互联网
目录
  • 一、模板
    • 1.1.函数模板
      • 1.1.1.两种函数模板的实例化
      • 1.1.2.模板参数的匹配原则
    • 1.2.类模板
    • 二、STL
      • 总结

        一、模板

        对于一个交换函数，虽然C++支持函数重载，我们可以对多个交换函数起相同的名字：

        void Swap(int& left, int& right) 
{
 int temp = left;
 left = right;
 right = temp; 
 }
void Swap(double& left, double& right) 
{
 double temp = left;
 left = right;
 right = temp; 
 }

        但是依然有不足的地方，比如如果我们要交换其他类型，比如char或者类类型，那还是得再写一个交换函数，这样原来写好的其他类型的交换函数就没有复用起来，大大降低了效率。

        因此，C++引入了模板的概念，通过模板，即可实现一份代码交换不同数据。

        模板，其实就是告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码。

        1.1.函数模板

        **泛型编程：**在之前，函数都是针对某个具体的类型（比如int，char），而泛型则是针对一个广泛的类型。模板则是泛型编程的基础。

        所以函数模板的参数并不是一个具体的类型，只有当调用时才能确定具体的类型。

        其语法为：

        //定义模板参数T可以用typename，也可以使用class
template<typename T1, typename T2,......,typename Tn>
返回值类型 函数名(用泛型指定的参数列表)
{
}

        以交换函数为例：

        template<typename T>
void Swap(T& left, T& right) 
{
	T temp = left;
	left = right;
	right = temp;
}
int main()
{
	int a = 10, b = 20;
	double c = 1.1, d = 2.2;
	Swap(a, b);
	Swap(c, d);
	cout << a << " " << b << endl;
	cout << c << " " << d << endl;
}

        在这里插入图片描述

        从反汇编可以看出，这两个函数调用的并不是同一个函数：

        在这里插入图片描述

        这是因为函数模板不是一个实际的函数，编译器不会为其生成可执行代码。当调用函数模板时，编译器会对函数模板进行推演，根据传入实参的类型推出T的类型，然后实例化出不同类型的函数。

        1.1.1.两种函数模板的实例化

        用不同类型的参数使用函数模板时，称为函数模板的实例化。

        1.隐式实例化

        让编译器根据实参推演模板参数的实际类型

        当有多个类型的实参而模板参数列表中只有一个T时，编译器将无法推演出T的类型，此时可以将实参进行类型强转：

        在这里插入图片描述

        有趣的是，强转后需要用const T来接收，因为强转后传入的并不是c，而是c的临时变量，这个临时变量是具有常属性的。

        2.显式实例化

        在函数名后的<>中指定模板参数的实际类型

        通过这种方式可以不让编译器推演类型，而是使用我们指定的类型。

        在这里插入图片描述

        当然对于类型不同的参数也要使用const T来接收。

        1.1.2.模板参数的匹配原则

        一个非模板函数可以和一个同名的函数模板同时存在，调用的时候如果与非模板函数匹配，编译器会优先调用非模板函数。如果非模板函数不匹配或者进行了实例化，则会调用函数模板。

        1.2.类模板

        对于一个类的成员变量也可以使用模板，这样在定义类对象的时候就可以实例化出具有不同类型的成员变量和成员函数的对象了。

        如果类模板中函数放在类外进行定义时，需要加模板参数列表，否则会找不到T。

        模板也不支持分离编译，建议定义在一个文件中。

        以动态顺序表为例：

        template<class T>
class Vector
{
public:
	Vector(size_t capacity = 10)
		: _pData(new T[capacity])
		, _size(0)
		, _capacity(capacity)
	{}
	~Vector();
	 //头插尾插等函数实现。。。
	size_t Size() 
	{ 
		return _size; 
	}
	T& operator[](size_t pos)
	{
		assert(pos < _size);
		return _pData[pos];
	}
private:
	T* _pData;
	size_t _size;
	size_t _capacity;
};
//类模板中函数放在类外进行定义时，需要加模板参数列表，否则会
template <class T>
Vector<T>::~Vector()
{
	if (_pData)
		delete[] _pData;
	_size = _capacity = 0;
}
int main()
{
	Vector<int> s1;
	Vector<double> s2;//实例化两个不同的类对象
	return 0;
}

        类模板实例化与函数模板实例化不同，类模板实例化只能显示实例化，需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

        二、STL

        STL，英文全称 standard template library，中文可译为标准模板库或者泛型库，其包含有大量的模板类和模板函数，是 C++ 提供的一个基础模板的集合，用于完成诸如输入/输出、数学计算等功能。

        STL有六大组件，但主要包含容器、算法和迭代器三个部分。

        容器（Containers）：用来管理某类对象的集合。各种数据结构，如vector、list、deque、set、map等,用来存放数据，从实现角度来看，STL容器是一种class template。
        算法（Algorithms）：用来处理对象集合中的元素，各种常用的算法，如sort、find、copy、for_each。从实现的角度来看，STL算法是一种function template。
        迭代器（Iterators）：用来在一个对象集合的元素上进行遍历动作。扮演了容器与算法之间的胶合剂，共有五种类型，从实现角度来看，迭代器是一种将operator* , operator-> , operator++, operator–等指针相关操作予以重载的class template。所有STL容器都附带有自己专属的迭代器，只有容器的设计者才知道如何遍历自己的元素。原生指针(native pointer)也是一种迭代器。
        仿函数：行为类似函数，可作为算法的某种策略。从实现角度来看，仿函数是一种重载了operator()的class 或者class template。
        适配器：一种用来修饰容器或者仿函数或迭代器接口的东西。
        空间配置器：负责空间的配置与管理。从实现角度看，配置器是一个实现了动态空间配置、空间管理、空间释放的class tempalte。

        STL存在以下缺陷：

        STL库的更新太慢了。上一版靠谱是C++98，中间的C++03基本一些修订。C++11出来已经相隔了13年，STL才进一步更新。STL现在都没有支持线程安全。并发环境下需要我们自己加锁。且锁的粒度是比较大的。STL极度的追求效率，导致内部比较复杂。比如类型萃取，迭代器萃取。STL的使用会有代码膨胀的问题，比如使用vector/vector/vector这样会生成多份代码，当然这是模板语法本身导致的。

        总结

        本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注海外IDC网的更多内容！

        更多阅读