C++模板进阶

1. 反向迭代器参数只有正向迭代器怎么玩？

list尚且可以一战，vector就没戏了。只传正向迭代器过来对我们的挑战是

operator*和operator->的返回值是啥？你是T*和T&，但是我只有迭代器。

// ReverseIterator.h

#pragma once

namespace Yuucho
{
	template<class Iterator>
	struct Reverse_iterator
	{
		Iterator _it;
		typedef Reverse_iterator<Iterator> Self;
		
		Reverse_iterator(Iterator it)
			:_it(it)
		{}

        // 返回值是啥？
		operator*()
		{
			Iterator tmp = _it;
			return *(--tmp);
		}

        // 返回值是啥？
		operator->()
		{
			return &(operator*());
		}

		Self& operator++()
		{
			--_it;
			return *this;
		}

		Self& operator--()
		{
			++_it;
			return *this;
		}

		bool operator!=(const Self& s)
		{
			return _it != s._it;
		}
	};
}

我们来看看SGI的源码是怎么解决这个问题的：他是在正向迭代器类里面多设置了几个内嵌类型：

有了这个东西，那我们刚刚的问题就解决了。

template<class Iterator>
struct Reverse_iterator
{
	Iterator _it;
	typedef Reverse_iterator<Iterator> Self;
		
	Reverse_iterator(Iterator it)
		:_it(it)
	{}

	Iterator::reference operator*()
	{
		Iterator tmp = _it;
		return *(--tmp);
	}

	Iterator::pointer operator->()
	{
		return &(operator*());
	}
    // ......
}

但是这样写还是有一个小问题，编译器并不认识Iterator::reference，大家想一想原因是什么？

因为Iterator是一个类模板，还没有实例化，编译器规定不能去找，因为找出来可能是带虚拟类型T的。

类模板、模板虚拟类型还没有实例化之前不能去它里面找内嵌定义的类型。类模板没有实例化，找出来也是虚拟类型，后期无法处理。

解决方法：在Iterator::reference之前加上typename关键字。

typename告诉编译器Iterator::reference是一个类型，等Iterator实例化以后，你再去它里面找这个内嵌类型。

我们跟库里保持一致：

template<class Iterator>
struct Reverse_iterator
{
	Iterator _it;
	typedef Reverse_iterator<Iterator> Self;
	typedef typename Iterator::reference reference;
	typedef typename Iterator::pointer pointer;
    
	Reverse_iterator(Iterator it)
		:_it(it)
	{}

	reference operator*()
	{
		Iterator tmp = _it;
		return *(--tmp);
	}

	pointer operator->()
	{
		return &(operator*());
	}
    // ......
}

但是vector、string还是玩不了，因为只有在自定义类型才能typedef设置内嵌类型，但是vector和string的迭代器都是原生指针。

两种解决方法：

1. vector和string分别写一个类去封装原生指针。
2. 迭代器萃取，通过特化来解决。

1.1 虚拟类型问题

假设我想用函数模板来写一个能打印存储不同类型的链表，写出了如下代码，大家想一想这个代码有没有问题？

template<class T>
void print_list(const list<T>& lt)
{
    list<T>::const_iterator cit = lt.begin();
    while(cit != lt.end())
    {
        cout << *cit << " ";
        ++cit;
    }
    cout << endl;
}

同样的道理list<T>是一个类模板，模板参数没确定，没有实例化之前不能取它里面的内嵌类型，解决方法和之前一样加上typename。

2. 非类型模板参数

2.1 array

我们来看一看array：它是一个定长的数组，且空间开在栈上。

所以说它只能和原生数组比较：

array纯废物，既然如此，为什么不用vector呢？

2.2 定义静态栈

非类型模板参数还可以用来定义静态栈：

// 静态栈
template<class T>
class Stack
{
private:
	T _a[N];
	int _top;
};

int main()
{
	Stack<int> st1;    // 100
	Stack<double> st2; // 500
	return 0;
}

非类型模板参数不能修改，浮点数、类对象以及字符串不允许作为非类型模板参数。

3. 模板特化

3.1 概念

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理，比如：实现了一个专门用来进行小于比较的函数模板。

// 函数模板 -- 参数匹配
template<class T>
bool Less(T left, T right)
{
	return left < right;
}

然后我们让它来比较日期：

我们看到当传两个日期对象的指针时，比较结果不一定正确，因为比较地址去了。

有人会问传*p1、*p2不就行了吗，我们这为了讲解特化问题，规定不传*p1、*p2 。

3.2 函数模板特化

函数模板的特化步骤：
(1). 必须要先有一个基础的函数模板
(2). 关键字template后面接一对空的尖括号<>
(3). 函数名后跟一对尖括号，尖括号中指定需要特化的类型
(4). 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。

// 函数模板 -- 参数匹配
template<class T>
bool Less(T left, T right)
{
return left < right;
}
// 对Less函数模板进行特化
template<>
bool Less<Date*>(Date* left, Date* right)
{
    return *left < *right;
}

cout << Less(p1, p2) << endl; // 调用特化之后的版本，而不走模板生成了

注意：一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出：

bool Less(Date* left, Date* right)
{
	return *left < *right;
}

该种实现简单明了，代码的可读性高，容易书写，因此函数模板不建议特化。

3.3 类模板特化

3.3.1 全特化

全特化即是将模板参数列表中所有的参数都确定化 。

template<class T1, class T2>
class Data
{
public:
    Data() {cout<<"Data<T1, T2>" <<endl;}
private:
    T1 _d1;
    T2 _d2;
};

template<>
class Data<int, char>
{
public:
    Data() {cout<<"Data<int, char>" <<endl;}
private:
    int _d1;
    char _d2;
}

3.3.2 偏特化/半特化

偏特化：任何针对模版参数进一步进行条件限制设计的特化版本。

(1) 将模板参数类表中的一部分参数特化

// 将第二个参数特化为char
// 只要第二个参数是char就会匹配偏特化
template <class T1>
class Data<T1, char>
{
public:
    Data() {cout<<"Data<T1, int>" <<endl;}
private:
    T1 _d1;
    char _d2;
};

(2)将参数进一步限制

偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。

//两个参数偏特化为指针类型，只要是指针就匹配这个
//只要一个参数是指针就匹配原生的模板
template <class T1, class T2>
class Data <T1*, T2*>
{
public:
    Data() {cout<<"Data<T1*, T2*>" <<endl;}
private:
    T1 _d1;
	T2 _d2;
};

//两个参数偏特化为引用类型
//同样只有一个参数是引用，匹配原生模板
template <typename T1, typename T2>
class Data <T1&, T2&>
{
public:
    Data(const T1& d1, const T2& d2)
    : _d1(d1)
    , _d2(d2)
    {
    cout<<"Data<T1&, T2&>" <<endl;
    }
private:
    const T1 & _d1;
    const T2 & _d2;
};

4. 特化的使用场景

4.1 对日期类排序

#include<vector>
#include <algorithm>

template<class T>
struct Less
{
	bool operator()(const T& x, const T& y) const
	{
		return x < y;
	}
};

//template<>
//struct Less<Date*>
//{
//	bool operator()(Date* x, Date* y) const
//	{
//		return *x < *y;
//	}
//};

// 偏特化 只要是指针都走我(Date* int*)
template<class T>
struct Less<T*>
{
	bool operator()(T* x, T* y) const
	{
		return *x < *y;
	}
};
//
//int main()
//{
//	Date d1(2022, 7, 7);
//	Date d2(2022, 7, 6);
//	Date d3(2022, 7, 8);
//
//	vector<Date> v1;
//	v1.push_back(d1);
//	v1.push_back(d2);
//	v1.push_back(d3);
//	// 可以直接排序，结果是日期升序
//	sort(v1.begin(), v1.end(), Less<Date>());
//
//	vector<Date*> v2;
//	v2.push_back(&d1);
//	v2.push_back(&d2);
//	v2.push_back(&d3);
//
//	// 可以直接排序，结果错误日期还不是升序，而v2中放的地址是升序
//	// 此处需要在排序过程中，让sort比较v2中存放地址指向的日期对象
//	// 但是走Less模板，sort在排序时实际比较的是v2中指针的地址，因此无法达到预期
//  // 需要特化处理
//	sort(v2.begin(), v2.end(), Less<Date*>());
//
//	vector<int*> v3;
//	v3.push_back(new int(3));
//	v3.push_back(new int(1));
//	v3.push_back(new int(2));
//	sort(v3.begin(), v3.end(), Less<int*>());
//
//	return 0;
//}

4.2 迭代器萃取

写一个萃取类来特化vector和string的原生指针迭代器，大家当科普来看，具体实现很复杂，而且基本上不考。