C++STL迭代器

最新推荐文章于 2022-03-08 11:53:40 发布

Huang Jason

最新推荐文章于 2022-03-08 11:53:40 发布

阅读量314

点赞数

文章标签： c++ 开发语言后端 c语言

本文链接：https://blog.csdn.net/JustCallMeYuan/article/details/122237964

版权

迭代器：

迭代器就是一个类种类，通过运算符重载类种类的对象去遍历容器

迭代器的分类

正向迭代器：iterator

初始化

begin（）

end()

反向迭代器reverse_iterator

rbegin（）

rend（）

常正向迭代器const_iterator

cbegin()

cend()

常反向迭代器const_reverse_iterator

crbegin()

crend()

按功能分类

正向迭代器

双向迭代器（可以++可以--）

随机访问迭代器

容器中迭代器分类（一般连续性内存都支持随机访问）

容器名迭代器类型

array 随机访问（支持数组下表随机访问）

vector 随机访问

deque 随机访问

stack/queue/priority_queue 不支持（特定顺序存储，没有迭代器）

list 双向

set/multiset 双向

map/multiset 双向

迭代器辅助函数

移动：advance(iterator iter,n); 迭代器的移动

间距：distance（iterator begjin，iterator end); 两个迭代器中间有多少个元素

交换：iter_swap(iterator first,iterator end);

拓展内容：特殊迭代器流型迭代器（一半用在辅助打印）

输出流型：(两种构造方式)

ostream_iterator<_Ty> iter(ostream& out);

ostream_iterator<_Ty> iter(ostream& out,char* str);

输出流型迭代器做赋值运算，意味着就是打印数据到屏幕上

输入流型

istream_iterator<_Ty> iter; //构造无参对象是一个错误流end_of_ostream

(数据如果不满足输入格式就会返回一个错误流)

istream_iterator<_Ty> iter(istream& in);

*iter 等效于cin>>操作

#include<iostream>
#include<vector>
#include<iterator>
using namespace std;

template<class _Ty>struct Node {
	_Ty data;
	Node<_Ty>* pNext;
	Node(_Ty data) :data(data), pNext(nullptr) {};
	Node(_Ty data, Node<_Ty>* pNext) :data(data), pNext(pNext) {};
};

template<class _Ty>class My_List {
public:
	My_List() :frontNode(nullptr), tailNode(nullptr) {
		curSize = 0;
	}
	void push_front(int data) {
		if (curSize == 0) {
			frontNode = new Node<_Ty>(data);
			tailNode = frontNode;
		}
		else {
			frontNode = new Node<_Ty>(data, frontNode);
		}
		curSize++;
	}
	void push_back() {

	}
	Node<_Ty>* begin() {
		return frontNode;
	}
	Node<_Ty>* end() {
		return nullptr;	//返回临时变量，需要复制，准备一个拷贝构造
	}
	class iterator {
	public:
		iterator(Node<_Ty>* pmove = nullptr) :pmove(pmove) {}
		iterator(const iterator& object) :pmove(object.pmove) {}		//没有申请内存用浅拷贝即可

		bool operator!=(Node<_Ty>* pmove)const {
			return this->pmove != pmove;
		}
		iterator operator++(int) {//后置++需要int 但这里就不实现了
			pmove = pmove->pNext;
			return iterator(pmove);
		}
		_Ty operator*() {
			return pmove->data;
		}
	protected:
		Node<_Ty>* pmove;	//迭代器实质：通过这个数据成员进行访问链表

	};
	void printTest() {
		Node<_Ty>* pmove = frontNode;
		while (pmove != nullptr) {
			cout << pmove->data << "\t";
			pmove = pmove->pNext;
		}
		cout << endl;

	}
protected:
	Node<_Ty>* frontNode;
	Node<_Ty>* tailNode;
	int curSize;
};
void testMy_List() {
	My_List<int> list;
	list.push_front(1);
	list.push_front(2);
	list.push_front(3);
	list.printTest();
	My_List<int>::iterator myIter = list.begin();
	for (; myIter != list.end(); myIter++) {
		cout << *myIter << "\t";
	}
	cout << endl;
}
void testIterator() {
	vector<int> data = { 1,2,3,4,5,6,7,8 };
	vector<int>::iterator iter;
	for (iter = data.begin(); iter != data.end(); iter++) {	//正反向迭代器只有++
		//对象模仿指针行为
		cout << *iter << "\t";
	}
	cout << endl;
	vector<int>::reverse_iterator rIter;
	rIter = data.rbegin();
	//auto rIter = data.rbegin();

	for (; rIter != data.rend(); rIter++) {
		cout << *rIter << "\t";
	}
	cout << endl;

	vector<int>::const_iterator c_iter;
	for (c_iter = data.cbegin(); c_iter != data.cend(); c_iter++) {	//不能做修改
	//对象模仿指针行为
		cout << *c_iter << "\t";
	}
	cout << endl;
}
void testExFunction() {
	vector<int> data = { 1,2,3,4,5,6,7,8 };
	vector<int>::iterator iter = data.begin();
	advance(iter, 3);
	cout << *iter << endl;
	cout << "distance:" << distance(data.begin(), data.end()) << endl;
	iter_swap(data.begin(), data.end() - 1);
	for (auto v : data) {
		cout << v << " ";
	}
	cout << endl;
}
void testIoIterator() {
	ostream_iterator<int> iter(cout);
	iter = 1243214;	//就是把这串数字打印到屏幕上
	cout << endl;
	ostream_iterator<int> iter2(cout, "我爱你");		//一般成为别人函数参数
	iter2 = 1314520;		//可以批处理容器里面的数据
	cout << endl;
	vector<int> data = { 1,2,3,4,5,6,7,8 };
	//等效打印
	copy(data.begin(), data.end(), ostream_iterator<int>(cout, "\t"));		//构造一个无名的
	cout << endl;

	//输入流型迭代器
	cout << "输入；流型迭代器测试" << endl;
	istream_iterator<int> end;	//	end_of_stream;
	istream_iterator<int> in(cin);
	vector<int> inputData;
	while (in != end) {
		inputData.push_back(*in);
		++in;
	}
	for (auto v : inputData) {
		cout << v << "\t";

	}
	cout << endl;
}

int main() {
	//testIterator();
	testMy_List();
	testExFunction();
	testIoIterator();
	return 0;
}

Lambda表达式

Lambda：就是一个返回函数指针的表达式，它定义和返回值函数指针在一起的

Lambda表达式组成部分

//[捕获方式](函数参数)mutable exception->函数返回值类型{函数体}

int Max(int a,int b){

return a>b?a:b;

}

void print(){ //Max的Lambda表达式写法

int(*pMax)(int,int)=[](int a,int b)mutable noexcept->int{

return a>b?a:b;

}

//省略写法

auto ppMax=[](int a,int b){

return a>b?a:b;

}

//捕获方式-->函数使用外部变量的方式

值的方式捕获 [=]:不会影响外部变量

引用的方式捕获 [&]:同步到外部变量

this指针的方式 [this]:捕获类中的数据成员

不捕获任何变量 []

组合的捕获方式 [=.&x]:x用引用方式捕获，其他变量用值的方式捕获

#include<iostream>
using namespace std;
void print(int(*pMax)(int, int), int a, int b) {
	cout << pMax(a, b) << endl;
}
class MM {
public:
	MM(string name,int age):name(name="张三"), age(age=18) {}
	void print() {
		[this] {cout << name << "\t" << age << endl; }();	//定义和调用一步到位，注意虽然没有参数但是调用还是要加（）
	}
protected:
	string name;
	int age;
};
int main() {
	int(*pMax)(int, int) = nullptr;
	pMax = [](int a, int b)mutable noexcept->int {
		return a > b ? a : b;
	};

	cout << pMax(1, 3) << endl;
	//省略版本
	auto pp = [](int a, int b) {return a > b ? a : b; };
	cout << pp(1, 3) << endl;
	//实际使用可以一步到位     一般短暂性的局部使用的函数用lambda函数实现，如回调函数
	cout << [](int a, int b)mutable noexcept->int {return a > b ? a : b; }(1, 3) << endl;

	print([](int a, int b)mutable noexcept->int {return a > b ? a : b; }, 1, 3);

	//捕获方式区别
	//用值的方式捕获：在Lambda中不能把值当作左值使用，函数的调用不会因为值的改变而改变
	int data = 101010;
	auto pFunc = [=] {cout << data << endl; };				//没有参数可以把参数省略
	auto pFunc2 = [&] {data,cout << data << endl; };
	pFunc();
	pFunc2();
	data = 9999;
	pFunc();
	pFunc2();

	MM mm("zhangsan",19);
	mm.print();

	//特殊的东西-->可以结合auto使用
	auto pAuto = [](auto a, auto b)->auto{return a > b ? a : b; };
	cout << pAuto(1, 3) << endl;	//因为实际在这里展开所以可以auto不赋值[](auto a, auto b)->auto{return a > b ? a : b; }（1，3）
	cout << pAuto("stringa", "stringb") << endl;	

	return 0;
}

仿函数

什么是仿函数：

类模仿函数调用的行为，实质是无名对象调用重载的（）函数

关键点在于重载（）

一般情况仿函数是做排序准则或者一些算法的计算准则

标准库仿函数

算术类

关系类

逻辑类

选择，证同，投射

#include<iostream>
#include<string>
#include<functional>	//标准库仿函数头文件
using namespace std;
class Sum {
public:
	int operator()(int a, int b)const {
		return a + b;
	}
protected:

};
int main() {
	//重载（）的调用
	//通过对象显示调用
	Sum sum;
	cout << "显示调用" << endl;
	sum.operator()(1, 2);
	//隐式调用
	cout << "隐式调用" << endl;
	sum(1, 2);
	//用（）{}帮助编译器解析，实质不需要
	cout << "无名调用" << Sum()(1, 3) << endl;	//类模仿函数调用的行为-->仿函数

	//算数
	cout << plus<int>{}(1, 3) << endl;
	cout << minus<int>{}(1, 3) << endl;
	cout << multiplies<int>{}(1, 3) << endl;
	//关系
	cout << equal_to<int>{}(1, 3) << endl;
	cout << not_equal_to<int>{}(1, 3) << endl;
	cout << greater<int>{}(1, 3) << endl;
	cout << less<int>{}(1, 3) << endl;

	//逻辑
	cout << logical_and<int>{}(1, 3) << endl;
	//大于3小于10，花里胡哨写法
	int a = 34;
	if (logical_and<int>{}(a > 3, a < 10)) {
		cout << "这个数大于三小于十" << endl;
	}


	return 0;
}

函数适配器

什么是函数适配器？

用来绑定函数调用时侯的参数，让函数适应其他调用的用法。

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<functional>
using namespace std;
//老版本bind1st bind2nd
//新版本bind函数
int Max(int a, int b) {
	return a > b ? a : b;
}
void print(int (*pMax)(int), int a) {
	cout << pMax(a) << endl;
}
class Test {
public:
	void print(int a, int b, int c) {
		cout << a << " " << b << " " << c << endl;
	}
protected:

};
void testClassFunc() {
	Test test;
	//注意两点1.类名取地址符，2.多一个参数，指明是哪个对象的
	auto testFunc = bind(&Test::print, &test, std::placeholders::_1, std::placeholders::_2, 99);
	//调用直接调用，不用对象
	testFunc(1, 3);
}
void printData(int one, Test two, string str) {
	cout << "调用成功" << endl;
}
//可以通过占位符，随意调整参数位置，形成不同调用形态
void testExUser() {
	auto testFunc = bind(printData, std::placeholders::_3, std::placeholders::_1, std::placeholders::_2);
	printData(1, Test(), "Iloveyou");
	//testFunc(1, Test(), "Iloveyou");	//报错
	//testFunc("ilove", 3, Test());		//报错，占位符代表的是原来的参数要去第几位
	testFunc(Test(), "Iloveyou", 3);
}
int main() {
	cout << Max(1, 3) << endl;
	//bind返回值是函数指针

	//using namespce std::placeholders
	auto pMax = bind(Max,std::placeholders::_1, 100);		//第一个参数是一个占位符，最多有20个占位符，把第二个参数置为100
	cout << pMax(23) << endl;
	cout << pMax(23,43) << endl;	//第二个参数不会是43，仍然是100
	//print(pMax, 23);
	vector<int> vecData = { 432,34,2,36,345,6,3,76,687,45433 };
	cout << count_if(vecData.begin(), vecData.end(), bind(greater<int>(), std::placeholders::_1, 60)) << endl;
	
	cout << count_if(vecData.begin(), vecData.end(), [](int a)mutable noexcept->int {return a > 60 ; }) << endl;

	testExUser();

	return 0;
}

函数包装器

什么是函数包装器？

就是把函数指针包装成一个对象，通过对象调用函数。

注意点：

一旦函数指针被函数包装器包装了，那这个包装器可以直接替换函数指针用法去调用函数。

函数包装器类的实例化传参：function<函数返回值类型（参数类型）>

#include<iostream>
#include<string>
#include<functional>
using namespace std;
int Max(int a, int b) {
	cout << "包装普通函数" << endl;
	return a > b ? a : b;
}
class MM {
public:
	void print(int a) {	//成员函数在解析的时候都会传入一个this指针，而static函数不会 void print(int a,MM* mm )
		cout << "包装成员函数" << endl;
	}
	static void printStatic() {
		cout << "包装静态的函数" << endl;
	}
protected:

};
class Test {
public:
	void operator()(string str) {
		cout << str << endl;
	}
protected:

};
//结合bind函数包装
void printData(int a, MM mm, string str) {
	cout << "bind和function" << endl;
}
void TestFuncBind() {
	function<void(string,int,MM)> pf=bind(printData,std::placeholders::_2,std::placeholders::_3,std::placeholders::_1);
	pf("string", 1, MM());
}
//包装成员函数
void testMMFunc() {
	MM mm;
	function<void(int)> func = bind(&MM::print, &mm, std::placeholders::_1);	//结合bind函数把this指针绑在一起
	func(23);
}
int main() {
	function<int(int, int)> funcMax(Max);
	cout << funcMax(1, 3) << endl;
	function<int(int, int)> funcMax2 = Max;
	function<void()> funS(MM::printStatic);
	funS();
	/*MM mm;
	function<void()> funMM(MM::print);*/

	Test test;
	function<void(string)> func = test;
	func("仿函数包装");
	

	TestFuncBind();
	return 0;
}