C++沉思录读书笔记（19章）- 使用泛型迭代器将泛型算法应用到不同的场合

这回将介绍，如何使用不同的迭代器，将一个泛型算法应用到不同的场合

我将使用泛型算法Copy为例子，利用不同的迭代器去应用这个算法，此算法代码如下:

template <class In, class Out>
Out Copy(In start, In end, Out dest) //模板copy在名称空间std中已经包含，为与标准版本区别而命名为Copy
{
	while(start != end)
		*dest++ = *start++;
	return dest;
}

应用一：
使用char *作为迭代器，也就是将In和Out都实例化为char *来应用这个泛型算法
这个应用的目的是将由start和end限定的字符序列拷贝到以dest为开始位置的序列中，代码非常简单，如下所示：

#include <iostream>
using namespace std;
template <class In, class Out>
Out Copy(In start, In end, Out dest) //此模板在名称空间std中已经包含，为与标准版本区别而命名为Copy
{
	while(start != end)
		*dest++ = *start++;
	return dest;
}
void main()
{
	char * hello = "Hello ";
	char * world = "world";
	char message[15];
	char *p = message;
	p = Copy(hello, hello+6, p); //使用自定义的Copy泛型算法
	p = copy(world, world+5, p); //使用标准copy泛型算法
	*p = '\0';
	cout << message << endl;
}

运行结果为：

Hello world

应用二：
我们的目的是将一个整形等差数列存到一个整形数组中
显然这次Out将实例化为int *；而对于In,需要创建一个输入迭代器，这个迭代器命名为Constant_iterator
完整代码如下所示：

#include <iostream>
using namespace std;
template <class In, class Out>
Out Copy(In start, In end, Out dest) //此模板在名称空间std中已经包含，为与标准版本区别而命名为Copy
{
	while(start != end)
		*dest++ = *start++;
	return dest;
}

class Constant_iterator
{
private:
	int n;
	int c;  //存储差值
	friend bool operator!=(const Constant_iterator&, const Constant_iterator&);
	friend Constant_iterator operator+(const Constant_iterator&, int x);
public:
	Constant_iterator(int x=1, int m=1): n(x),c(m) {};
	Constant_iterator operator++(int)
	{
		Constant_iterator r = *this;
		n+=c;
		return r;
	}
	int operator*() { return n; }
};

bool operator!=(const Constant_iterator& a, const Constant_iterator& b)
{
	return a.n != b.n;
}

Constant_iterator operator+(const Constant_iterator& a, int x)
{
	Constant_iterator r = a;
	r.n += x*(r.c);
	return r;
}

void main()
{
	int x[100];
	Constant_iterator c(-1,-2);
	Copy(c, c+5, x);
	for(int i = 0;i<100; i++)
		cout << i << " " << x[i] << endl;
}

运行结果为：

0 -1
1 -3
2 -5
3 -7
4 -9

应用三：
应用二中，我们的输出迭代器是int *，这次我们将输出迭代器设置成为一个输出流迭代器，我们重新新定义一个输出流迭代器Ostream_iterator；输入迭代器同应用二
我们的目的是使用泛型算法输出一个等差数列，整体代码如下所示：

#include <iostream>
#include <iterator>
using namespace std;
template <class In, class Out>
Out Copy(In start, In end, Out dest) //此模板在名称空间std中已经包含，为与标准版本区别而命名为Copy
{
	while(start != end)
		*dest++ = *start++;
	return dest;
}

class Constant_iterator
{
private:
	int n;
	int c;  //存储差值
	friend bool operator!=(const Constant_iterator&, const Constant_iterator&);
	friend Constant_iterator operator+(const Constant_iterator&, int x);
public:
	Constant_iterator(int x=1, int m=1): n(x),c(m) {};
	Constant_iterator operator++(int)
	{
		Constant_iterator r = *this;
		n+=c;
		return r;
	}
	int operator*() { return n; }
};

bool operator!=(const Constant_iterator& a, const Constant_iterator& b)
{
	return a.n != b.n;
}

Constant_iterator operator+(const Constant_iterator& a, int x)
{
	Constant_iterator r = a;
	r.n += x*(r.c);
	return r;
}

template<class T>
class Ostream_iterator
{
private:
	ostream * strm;
	const char * str;
public:
	Ostream_iterator(ostream& os, const char * s): strm(&os), str(s) {}
	Ostream_iterator& operator++(int) { return *this; }
	Ostream_iterator& operator=(const T& t) 
	{
		*strm << t << str;
		return *this;
	}
	Ostream_iterator& operator*() { return *this;}
};

void main()
{
	Ostream_iterator<int> oi(cout, "\n");
	Constant_iterator c(-1,-2); //初值为-1，差值为-2
	Copy(c, c+5, oi); //数列长度为5
	//ostream_iterator<int> output(cout, "*");
	//copy(c, c+5, output);  //此句编译通不过，因为Constant_iterator还不完善，所以它步支持标准版本的copy
}

运行结果为：

-1
-3
-5
-7
-9

还可以将输入迭代器实例化为输入流迭代器，代码略

总结：在设计算法时我们可以指针进行操作，然后将其抽象，对于不存在指针的数据结构，我们构造它的迭代器来模拟指针操作。要注意，使用泛型算法的数据结构也许根本不存在，具体请参看应用二