iterator(迭代器)解析

Posted 2022-11-25 隐无影

C++完成线性查找

c语言函数find查找只能查找某一个类型的数组,在C++中可以使用模板

template<class T>//C++模板
T *find2(T *first, T *last, T value);

更一般化

template<class Iterator ,class T>
Iterator find(iterator first, Iterator last, const T &value)

	while (first != last&&first != value)
		++first;
	return first;

我们同样可以使用find函数实现链表查找但有以下不能像数组那样

struct int_node

	int val;
	int_node *next;
;

原因:比如first是int_node的指针,find会使用++first指向下一个元素,这会引发不定义行为,因为是链表而非数组

比如p是int_node的指针,下一个节点应该是p->next,而非p+1;

链表遍历一般化

int_node *p;
for (p = list_head; p != nullptr; p = p->next)

如何解决用find来实现链表查找答案如下

C++可以操作符重载,operator++可以使得find可以正确走过链表

我可以写一个简单的外覆类,使得看起来像个int_node*,其operator有更好的定义

#include<iostream>
using namespace std;
struct int_node

	int val;
	int_node *next;
;
template<class Iterator,class T>
Iterator find1(Iterator first, Iterator last,const T &value)

	while (first != last&&*first != value)
		++first;
	return first;

template<class Node>
struct node_wrap

	Node *ptr;
	//构造函数
	node_wrap(Node *p = nullptr) :ptr(p) 
	Node& operator*() const  return *ptr; 
	Node*operator->() const  return ptr; 
	node_wrap&operator++() ptr = ptr->next; return *this; 
	node_wrap operator(int)  node_wrap tmp = *this; ++*this; return tmp; 

	bool operator==(const node_wrap &i)const  return ptr == i.ptr; 
	bool operator!=(const node_wrap &i)const  return ptr != i.ptr; 
	bool operator==(const int_node &node, int n)  return node.val == n; 
;
int main()

	int_node *list_head;
	int val = 0;
	             //匿名对象                          //匿名对象
	find1(node_wrap<int_node>(list_head), node_wrap< int_node>(), val);

Iterators

Iterators是指针的概括物,它们是用来指向其他对象的一种对象,

Iterators是算分与数据结构之间的接口

Iterator有几种类型(input iterator,Output Iterator ,Forward Iterator Bidirectional iterator ,Random Access Iterator)

1.input iterator类似指针的东西

1.1当作一般c指针时,可以取值,可以跨越尾端,可以为nullptr

1.2可以比较性别为iterator的对象的相等性

1.3input ierator可以赋值或者复制

1.4可以解引用一个iterator的对象,每一个input iterator都有一个相关对象的型别,

1.5可以对一个型别尾iterator的对象进行累加动作

1.6 input iterator是指针运算的一小部分

1.7 input iterator不能比大小,只能比相等

.

2.Output Iterators

input iterator是读入动作,output iterator是写的动作

用copy函数举例子

template<class InputIterator, class OutputIterator>
OutputIterator  copy(InputIterator first, InputIterator last, OutputIterator result)

	for (; first != last; ++result, ++first)
		*result = *first;
	return result;

output的需求条件跟input 类是

跟input iterator,可以复制和赋值output iterator

我们可以使用output iterator写值

我们可以累加output iterator

注意;output ierator只有可写性

output iterator其源代码

template<class T>
class ostream_iterator

private:
	ostream *os;
	const char *string;
public:
	ostream_iterator(ostream &s, const char *c = 0) :os(&s), string(c)
	ostream_iterator(const ostream_iterator &i) :os(i.os), string(i.string) 
	ostream_iterator &operator=(const ostream_iterator &i)
	
		os = i.os;
		string = i.string;
		return *this;
	
	ostream_iterator<T> &operator=(const T &value)
	
		*os << value;
		if (string)*os << string;
		return *this;
	
	ostream_iterator<T>& operator *()  return *this; 
	ostream_iterator<T>& operator++()  return *this; 
	ostream_iterator<T>& operator(int)()  return *this; 
;

Forward iterators  

input iterator只可读,output iterator具有可写性,如果需要可读并且更改那就使用forward iterators

template<class ForwardIterator,class T>
void replace(ForwardIterator first, ForwardIterator last, const T &old_value, const T&new_value)

	for (;first!=last,++first)
	if (*first == old_value)//input iterator类型
		*first = new_value;//output iterator类型

查找是否连续二元素具有相同值

template<class ForwardIterator>
ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last)

	if (first == last)
		return last;
	ForwardIterator next = first;
	while (++next != last)
	
		if (*first == *next)
			return first;
		first = next;
	
	return last;

Bidirectional Iterators

可以multipass算法,支持双向移动

template<class BidirectionalIterator,class OutputIterator>
OutputIterator reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator result)

	while (first != last)
	
		--last;
		*result = *last;
		++result;

	
	return result;

Random Access Iterators

涵盖了指针所有运算,这里就不举例子了

总结

iterator定义为指针的一般化形式