• C++：栈与队列，优先级队列

    目录

    一.栈与队列，优先级队列的介绍

    2.适配器

    二.栈与队列，优先级队列的使用

    三.栈和队列相关题目

    1.155. 最小栈

    2.栈的压入、弹出序列

    3.150. 逆波兰表达式求值

    四.模拟实现

    1.stack

    2.queue

    3.优先级队列 priority_queue

    易错点：

    重点

    （1）top()返回类型    const T& 的原因

     （2）仿函数 #include

    priority_queue代码

    4.deque与vector，list对比

    vector：

    list：   

    deque：#include

    5.总结：

    五.仿函数

    1.

     2.例子2：指向数组的原生指针，本身就是天然迭代器

    六.反向迭代器

    七.typename

    一.栈与队列，优先级队列的介绍

    2.适配器

    适配器是一种设计模式 ( 设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结) ， 该种模式是将一个类的接口转换成客户希望的另外一个接口 。

    二.栈与队列，优先级队列的使用

    优先级队列的问题:优先级队列默认大的优先级高，传的是less仿函数，底层是一个大堆；
    想控制小的优先级高，传greater仿函数，底层是一个小堆。这个反过来的，算是设计的一个失误。

    （实际上less——大堆，greater——小堆，greater可理解为小堆下面越来越大）

    1. #include
    2. #include
    3. #include
    4. #include 
    5. using namespace std;
    6. namespace std
    7. {
    8. 	void test_stack()            //栈
    9. 	{
    10. 		stack<int> s;
    11. 		s.push(1);
    12. 		s.push(2);
    13. 		s.push(3);
    14. 		s.push(4);
    15.  
    16. 		while (!s.empty())
    17. 		{
    18. 			cout << s.top() << " ";
    19. 			s.pop();
    20. 		}
    21. 		cout << endl;
    22. 	}
    23.  
    24. 	void test_queue()            //队列
    25. 	{
    26. 		queue<int> q;
    27. 		q.push(1);
    28. 		q.push(2);
    29. 		q.push(3);
    30. 		q.push(4);
    31.  
    32. 		while (!q.empty())
    33. 		{
    34. 			cout << q.front() << " ";
    35. 			q.pop();
    36. 		}
    37. 		cout << endl;
    38. 	}
    39.  
    40. 	void test_priority_queue()            //优先级队列
    41. 	{
    42. 		//priority_queue pq;
    43. 		priority_queue<int, vector<int>, greater<int>> pq;
    44.  
    45. 		pq.push(2);
    46. 		pq.push(5);
    47. 		pq.push(1);
    48. 		pq.push(6);
    49. 		pq.push(8);
    50.  
    51. 		while (!pq.empty())
    52. 		{
    53. 			cout << pq.top() << " ";
    54. 			pq.pop();
    55. 		}
    56. 		cout << endl;
    57. 	}
    58. }
    59.  
    60. int main()
    61. {
    62. 	std::test_stack();
    63. 	std::test_queue();
    64. 	std::test_priority_queue();
    65.  
    66. 	return 0;
    67. }

    三.栈和队列相关题目

    1.155. 最小栈

    思路：用两个栈，st存放入的数据，minst存放入数据后的最小数据；

    优化：minst存放入数据后的最小数据，如果后面再尾插的数据都没有这个数据大，minst就不尾插数据，如果尾插的数据 小于或等于 minst中最后一个数据，就尾插这个数据进minst。

    举例：st第一个数据5，minst尾插一个5；st尾插8，8>5，minst不变；st尾插7，minst不尾插；st尾插2,2<5，尾插2；st尾插1,1<2，minst尾插1；st又尾插1,1=1，minst还要尾插1。（因为如果=时minst不尾插，pop数据时，st尾删一个1，minst就一个1，尾删后，st中还有一个1，最小值就乱了）

    1. class MinStack {
    2. public:
    3.     MinStack() {
    4.         //成员变量是自定义类型，默认生成够用
    5.     }
    6.     
    7.     void push(int val) {
    8.         _st.push(val);
    9.         if(_minst.empty()||val<=_minst.top())
    10.         {
    11.             _minst.push(val);
    12.         }
    13.     }
    14.     
    15.     void pop() {
    16.         if(_st.top()==_minst.top())
    17.         {
    18.             _minst.pop();
    19.         }
    20.         _st.pop();
    21.     }
    22.     
    23.     int top() {
    24.         return _st.top();
    25.     }
    26.     
    27.     int getMin() {
    28.         return _minst.top();
    29.     }
    30.  
    31. private:
    32.     stack<int> _st;    
    33.     stack<int> _minst;    
    34. };

    2.栈的压入、弹出序列

    栈的压入、弹出序列_牛客题霸_牛客网 (nowcoder.com)

    1. class Solution {
    2. public:
    3.     bool IsPopOrder(vector<int> pushV,vector<int> popV) {
    4.         stack<int> st;
    5.         int popi=0;
    6.         for(auto e: pushV)
    7.         {
    8.             st.push(e);
    9.             while(!st.empty() && st.top()==popV[popi])
    10.             {
    11.                 popi++;
    12.                 st.pop();
    13.             }
    14.         }
    15.         return st.empty();
    16.     }
    17. };

    3.150. 逆波兰表达式求值

    过程：逆波兰表达式又称后缀表达式

      手敲：

    1. class Solution {
    2. public:
    3.     int evalRPN(vector& tokens) {
    4.         stack<int> st;
    5.         for(auto e:tokens)
    6.         {
    7.             if(e=="+"||e=="-"||e=="*"||e=="/")
    8.             {
    9.                 int b=st.top();         //易错点1
    10.                 st.pop();
    11.                 int a=st.top();
    12.                 st.pop();
    13.                 switch(e[0])
    14.                 {
    15.                     case '+':
    16.                         st.push(a+b);
    17.                         break;
    18.                     case '-':
    19.                         st.push(a-b);
    20.                         break;
    21.                     case '*':
    22.                         st.push(a*b);
    23.                         break;
    24.                     case '/':
    25.                         st.push(a/b);
    26.                         break;
    27.                     default:
    28.                         break;
    29.                 }
    30.             }
    31.             else
    32.             {
    33.                   st.push(stoi(e));
    34.             }
    35.         }
    36.         return st.top();
    37.     }
    38. };

    四.模拟实现

    1.stack

    底层是vector，list，deque都可以（如果是string的话会截断）

    deque是双端队列（顺序表），适合头尾插入删除，不适合中间插入删除，不适合随机访问（虽然支持，但不适合随机访问）

    1. #pragma once
    2.  
    3. namespace bit
    4. {
    5. 	template<class T, class Container = deque>
    6. 	class stack
    7. 	{
    8. 	public:
    9. 		void push(const T& x)
    10. 		{
    11. 			_con.push_back(x);
    12. 		}
    13.  
    14. 		void pop()
    15. 		{
    16. 			_con.pop_back();
    17. 		}
    18.  
    19. 		const T& top()
    20. 		{
    21. 			return _con.back();
    22. 		}
    23.  
    24. 		size_t size()
    25. 		{
    26. 			return _con.size();
    27. 		}
    28.  
    29. 		bool empty()
    30. 		{
    31. 			return _con.empty();
    32. 		}
    33. 	private:
    34. 		Container _con;
    35. 	};
    36.  
    37. 	void test_stack()
    38. 	{
    39. 		//stack s;
    40. 		stack<int, vector<int>> s;
    41. 		//stack> s;
    42. 		//stack s; // ڽضݶʧ
    43.  
    44. 		s.push(1);
    45. 		s.push(2);
    46. 		s.push(3);
    47. 		s.push(4);
    48. 		s.push(300);
    49.  
    50. 		while (!s.empty())
    51. 		{
    52. 			cout << s.top() << " ";
    53. 			s.pop();
    54. 		}
    55. 		cout << endl;
    56. 	}
    57. }
    58.  
    59.  
    60. #include 
    61. #include 
    62. #include 
    63. #include 
    64. #include 
    65. #include 
    66. #include 
    67. #include 
    68. using namespace std;
    69.  
    70. #include "Stack.h"
    71. #include "Queue.h"
    72. #include"stack.h"
    73. int main()
    74. {
    75. 	bit::test_stack();
    76. 	return 0;
    77. }

    2.queue

    底层只能是list，或deque，因为vector不支持头删

    1. namespace bit
    2. {
    3. 	template<class T, class Container = deque>
    4. 	class queue
    5. 	{
    6. 	public:
    7. 		void push(const T& x)
    8. 		{
    9. 			_con.push_back(x);
    10. 		}
    11.  
    12. 		void pop()
    13. 		{
    14. 			_con.pop_front();
    15. 		}
    16.  
    17. 		const T& front()
    18. 		{
    19. 			return _con.front();
    20. 		}
    21.  
    22. 		const T& back()
    23. 		{
    24. 			return _con.back();
    25. 		}
    26.  
    27. 		size_t size()
    28. 		{
    29. 			return _con.size();
    30. 		}
    31.  
    32. 		bool empty()
    33. 		{
    34. 			return _con.empty();
    35. 		}
    36. 	private:
    37. 		Container _con;
    38. 	};
    39.  
    40. 	void test_queue()
    41. 	{
    42. 		//queue q;
    43. 		queue<int, list<int>> q;
    44. 		//queue> q; // 不行
    45.  
    46. 		q.push(1);
    47. 		q.push(2);
    48. 		q.push(3);
    49. 		q.push(4);
    50.  
    51. 		while (!q.empty())
    52. 		{
    53. 			cout << q.front() << " ";
    54. 			q.pop();
    55. 		}
    56. 		cout << endl;
    57. 	}
    58. }

    3.优先级队列 priority_queue

    易错点：

    Compare仿函数用法，向上下调整函数要传参，AjustDown函数忘记过程，pop函数忘记断言不为空，仿函数内()重载忘加const

    重点

    （1）top()返回类型    const T& 的原因

    如果T是string，则返回_con[0] 又会有拷贝构造，为了提高效率就加上引用，但加上引用就可以被任意修改，防止原数组被修改，就加上const

    1.  
    2. 		const T& top()    //const T&类型的原因，详情见（1）
    3. 		{
    4. 			return _con[0];
    5. 		}

     （2）仿函数 #include

    就是一个类重载了运算符(),并且这个类less或greater还是一个空类，Compare comFunc; 直接定义出一个对象，comFunc(_con[parent], _con[child]) 使用起来像一个函数一样。（变量comFunc 没必要放在成员变量中，因为对象的类是空类，创建的成本小）

    1.  // 仿函数/函数对象 -- 对象可以像调用函数一样去使用
    2.     /*struct less
    3. 	{
    4. 	bool operator()(int x, int y)
    5. 	{
    6. 	return x < y;
    7. 	}
    8. 	};*/
    9. 	template<class T>
    10. 	struct less
    11. 	{
    12. 		bool operator()(const T& x, const T&  y) const
    13. 		{
    14. 			return x < y;
    15. 		}
    16. 	};
    17.  
    18. 	template<class T>
    19. 	struct greater
    20. 	{
    21. 		bool operator()(const T& x, const T&  y) const
    22. 		{
    23. 			return x > y;
    24. 		}
    25. 	};
    26.  
    27. template<class T, class Container = vector, class Compare = less>//仿函数
    28. 	class priority_queue
    29. 	{
    30. 	public:
    31. 		void AdjustUp(int child)
    32. 		{
    33. 			Compare comFunc;                    //仿函数
    34. 			int parent = (child - 1) / 2;
    35. 			while (child > 0)
    36. 			{
    37. 				//if (_con[parent] < _con[child])
    38. 				if (comFunc(_con[parent], _con[child]))    //仿函数
    39. 				{
    40. 					swap(_con[parent], _con[child]);
    41. 					child = parent;
    42. 					parent = (child - 1) / 2;
    43. 				}
    44. 				else
    45. 				{
    46. 					break;
    47. 				}
    48. 			}
    49. 		}

    priority_queue代码

    1. #pragma once
    2.  
    3. namespace bit
    4. {
    5.  
    6.     // 仿函数/函数对象 -- 对象可以像调用函数一样去使用
    7.     /*struct less
    8. 	{
    9. 	bool operator()(int x, int y)
    10. 	{
    11. 	return x < y;
    12. 	}
    13. 	};*/
    14. 	template<class T>
    15. 	struct less
    16. 	{
    17. 		bool operator()(const T& x, const T&  y) const
    18. 		{
    19. 			return x < y;
    20. 		}
    21. 	};
    22.  
    23. 	template<class T>
    24. 	struct greater
    25. 	{
    26. 		bool operator()(const T& x, const T&  y) const
    27. 		{
    28. 			return x > y;
    29. 		}
    30. 	};
    31.  
    32. 	// 优先级队列 -- 大堆 <  小堆 >
    33. 	template<class T, class Container = vector, class Compare = less>//仿函数
    34. 	class priority_queue
    35. 	{
    36. 	public:
    37. 		void AdjustUp(int child)
    38. 		{
    39. 			Compare comFunc;                    //仿函数
    40. 			int parent = (child - 1) / 2;
    41. 			while (child > 0)
    42. 			{
    43. 				//if (_con[parent] < _con[child])
    44. 				if (comFunc(_con[parent], _con[child]))    //仿函数
    45. 				{
    46. 					swap(_con[parent], _con[child]);
    47. 					child = parent;
    48. 					parent = (child - 1) / 2;
    49. 				}
    50. 				else
    51. 				{
    52. 					break;
    53. 				}
    54. 			}
    55. 		}
    56.  
    57. 		void push(const T& x)
    58. 		{
    59. 			_con.push_back(x);
    60.  
    61. 			AdjustUp(_con.size() - 1);
    62. 		}
    63.  
    64. 		void AdjustDown(int parent)
    65. 		{
    66. 			Compare comFunc;                    //仿函数
    67. 			size_t child = parent * 2 + 1;
    68. 			while (child < _con.size())
    69. 			{
    70. 				//if (child+1 < _con.size() && _con[child] < _con[child+1])
    71. 				if (child + 1 < _con.size() && comFunc(_con[child], _con[child + 1]))
    72. 				{                                //仿函数
    73. 					++child;
    74. 				}
    75.  
    76. 				//if (_con[parent] < _con[child])
    77. 				if (comFunc(_con[parent],_con[child]))    //仿函数
    78. 				{
    79. 					swap(_con[parent], _con[child]);
    80. 					parent = child;
    81. 					child = parent * 2 + 1;
    82. 				}
    83. 				else
    84. 				{
    85. 					break;
    86. 				}
    87. 			}
    88. 		}
    89.  
    90. 		void pop()
    91. 		{
    92. 			assert(!_con.empty());
    93. 			swap(_con[0], _con[_con.size() - 1]);
    94. 			_con.pop_back();
    95.  
    96. 			AdjustDown(0);
    97. 		}
    98.  
    99. 		const T& top()    //const T&类型的原因，详情见（1）
    100. 		{
    101. 			return _con[0];
    102. 		}
    103.  
    104. 		size_t size()
    105. 		{
    106. 			return _con.size();
    107. 		}
    108.  
    109. 		bool empty()
    110. 		{
    111. 			return _con.empty();
    112. 		}
    113.  
    114. 	private:
    115. 		Container _con;
    116. 	};
    117.  
    118. 	void test_priority_queue()
    119. 	{
    120. 		/*less LessCom;
    121. 		cout << LessCom(1, 2) << endl;
    123. 		greater GreaterCom;
    124. 		cout << GreaterCom(1, 2) << endl;*/
    125.  
    126. 		//priority_queue pq;
    127. 		priority_queue<int, vector<int>, greater<int>> pq;
    128.  
    129. 		pq.push(2);
    130. 		pq.push(5);
    131. 		pq.push(1);
    132. 		pq.push(6);
    133. 		pq.push(8);
    134.  
    135. 		while (!pq.empty())
    136. 		{
    137. 			cout << pq.top() << " ";
    138. 			pq.pop();
    139. 		}
    140. 		cout << endl;
    141. 	}
    142.  
    143. }

    4.deque与vector，list对比

    vector：

    优点:
    适合尾插尾删，随机访问，cpu高速缓存命中高
    缺点:
    a、不适合头部或者中部插入删除，效率低，需要挪动数据
    b、扩容有一定性能消耗，还可能存在一定程度的空间浪费。

    list：   

    优点:
    a.任意位置插入删除效率高。O(1) b、按需申请释放空间。
    缺点:
    不支持随机访问
    cpu高速缓存命中低


    deque：#include

    deque (双端队列 ) ：是一种双开口的 " 连续 " 空间的数据结构 ，双开口的含义是：可以在头尾两端进行插入和 删除操作，且时间复杂度为O(1) ，与 vector 比较，头插效率高，不需要搬移元素；与 list 比较，空间利用率比较高。

    deque 并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际 deque 类似于一个动态的二维 数组

    根据vector和list缺点升级而成，虽然deque优点均衡但是不够极致，vector的随机访问效率最高很极致，list任意插入功能机制

    优点:
    a、头部和尾部插入删除数据效率不错
    b、支持随机访问。
    C、扩容代价小。
    d、cpu高速缓存命中高
    缺点:
    a、中部插入删除效率不行
    b、虽然支持随机访问，但是效率相比vector而言还是有差距，频繁随机访问要小心

    deque适用场景：大量头尾插入删除，偶尔随机访问（说的就是栈和队列）。stack，queue用deque作为默认适配容器是ok的

    5.总结：

    stack底层：deque，vector，list（尾插尾删都支持）

    queue：deque，list（vector不支持头插头删）

    priority_queue：vector，deque(deque不推荐，list不支持随机访问)

    五.仿函数

    1.

     2.例子2：指向数组的原生指针，本身就是天然迭代器

    1. 	    int a[6] = { 1, 2, 5, 2, 5, 7 };
    2. 		sort(a, a + 6);
    3. 		sort(a, a + 6, greater<int>());

    1. 	// 商品
    2. 	struct Goods
    3. 	{
    4. 		string _name;
    5. 		double _price;
    6. 		size_t _saleNum;
    7. 		//...
    8.  
    9. 		/*bool operator<(const Goods& g) const
    10. 		{
    11. 			return _price < g._price;
    12. 		}*/
    13. 	};
    14.  
    15. 	struct LessPrice    //按价格排序
    16. 	{
    17. 		bool operator()(const Goods& g1, const Goods& g2) const
    18. 		{
    19. 			return g1._price < g2._price;
    20. 		}
    21. 	};
    22.  
    23. 	struct GreaterPrice
    24. 	{
    25. 		bool operator()(const Goods& g1, const Goods& g2) const
    26. 		{
    27. 			return g1._price > g2._price;
    28. 		}
    29. 	};
    30.  
    31. 	struct LessSaleNum
    32. 	{
    33. 		bool operator()(const Goods& g1, const Goods& g2) const
    34. 		{
    35. 			return g1._saleNum < g2._saleNum;
    36. 		}
    37. 	};
    38.  
    39.  
    40. 	struct GreaterSaleNum
    41. 	{
    42. 		bool operator()(const Goods& g1, const Goods& g2) const
    43. 		{
    44. 			return g1._saleNum > g2._saleNum;
    45. 		}
    46. 	};
    47.  
    48. 	void test_functional()
    49. 	{
    50. 		vector<int> v;
    51. 		v.push_back(2);
    52. 		v.push_back(1);
    53. 		v.push_back(4);
    54. 		v.push_back(5);
    55. 		v.push_back(3);
    56.  
    57. 		for (auto e : v)
    58. 		{
    59. 			cout << e << " ";
    60. 		}
    61. 		cout << endl;
    62.  
    63. 		// less
    64. 		sort(v.begin(), v.end());
    65. 		for (auto e : v)
    66. 		{
    67. 			cout << e << " ";
    68. 		}
    69. 		cout << endl;
    70.  
    71. 		// greater
    72. 		sort(v.begin(), v.end(), greater<int>());
    73. 		for (auto e : v)
    74. 		{
    75. 			cout << e << " ";
    76. 		}
    77. 		cout << endl;
    78.  
    79. 		// 指向数组的原生指针，本身就是天然迭代器
    80. 		int a[6] = { 1, 2, 5, 2, 5, 7 };
    81. 		sort(a, a + 6);
    82. 		sort(a, a + 6, greater<int>());
    83.  
    84. 		Goods gds[4] = { { "苹果", 2.1, 1000}, { "香蕉", 3.0, 200}, { "橙子", 2.2,300}, { "菠萝", 1.5,50} };
    85.  
    86. 		sort(gds, gds + 4, LessPrice());    //按价格排升序 Less是升序排
    87. 		sort(gds, gds + 4, GreaterPrice()); //按价格排降序 Greater是降序排
    88. 		sort(gds, gds + 4, LessSaleNum());    //按销量排升序
    89. 		sort(gds, gds + 4, GreaterSaleNum());    //按销量排降序
    90. 	}

    六.反向迭代器

    反向迭代器跟正向迭代器相比，除了++/--时方向相反，其他操作基本一致

    自己模拟实现的：

     反向迭代器代码放在 ReverseIterator.h 中：

    1. #pragma once
    2.  
    3. namespace bit
    4. {
    5. 	//  -- 
    6. 	template<class Iterator, class Ref, class Ptr>
    7. 	struct Reverse_iterator
    8. 	{
    9. 		Iterator _it;
    10. 		typedef Reverse_iterator Self;
    11. 		
    12. 		Reverse_iterator(Iterator it)
    13. 			:_it(it)
    14. 		{}
    15.  
    16. 		Ref operator*()
    17. 		{
    18. 			Iterator tmp = _it;
    19. 			return *(--tmp);
    20. 		}
    21.  
    22. 		Ptr operator->()
    23. 		{
    24. 			return &(operator*());
    25. 		}
    26.  
    27. 		Self& operator++()
    28. 		{
    29. 			--_it;
    30. 			return *this;
    31. 		}
    32.  
    33. 		Self& operator--()
    34. 		{
    35. 			++_it;
    36. 			return *this;
    37. 		}
    38.  
    39. 		bool operator!=(const Self& s)
    40. 		{
    41. 			return _it != s._it;
    42. 		}
    43. 	};
    44. }
    1. namespace bit
    2. {
    3. 	template<class T>
    4. 	class vector
    5. 	{
    6. 	public:
    7. 		typedef T* iterator;
    8. 		typedef const T* const_iterator;
    9.  
    10. 		// 反向迭代器适配支持
    11. 		typedef Reverse_iterator reverse_iterator;
    12. 		typedef Reverse_iteratorconst T&, const T*> const_reverse_iterator;
    13.  
    14. 		const_reverse_iterator rbegin() const
    15. 		{
    16. 			// list_node*
    17. 			return const_reverse_iterator(end());
    18. 		}
    19.  
    20. 		const_reverse_iterator rend() const
    21. 		{
    22. 			return const_reverse_iterator(begin());
    23. 		}
    24.  
    25. 		reverse_iterator rbegin()
    26. 		{
    27. 			return reverse_iterator(end());
    28. 		}
    29.  
    30. 		reverse_iterator rend()
    31. 		{
    32. 			return reverse_iterator(begin());
    33. 		}
    34.         ……
    35.  
    36. 对vector中反向迭代器的测试：
    37. void test_vector8()
    38. 	{
    39. 		vector<int> v;
    40. 		v.push_back(10);
    41. 		v.push_back(20);
    42. 		v.push_back(30);
    43. 		v.push_back(40);
    44. 		v.push_back(50);
    45.  
    46. 		vector<int>::reverse_iterator rit = v.rbegin();
    47. 		while (rit != v.rend())
    48. 		{
    49. 			cout << *rit << " ";
    50. 			++rit;
    51. 		}
    52. 		cout << endl;
    53. 	}

    1. template<class T>
    2. 	class list
    3. 	{
    4. 		typedef list_node Node;
    5. 	public:
    6. 		typedef __list_iterator iterator;
    7. 		typedef __list_iteratorconst T&, const T*> const_iterator;
    8.  
    9. 		// 反向迭代器适配支持
    10. 		typedef Reverse_iterator reverse_iterator;
    11. 		typedef Reverse_iteratorconst T&, const T*> const_reverse_iterator;
    12.  
    13. 		const_iterator begin() const
    14. 		{
    15. 			// list_node*
    16. 			return const_iterator(_head->_next);
    17. 		}
    18.  
    19. 		const_iterator end() const
    20. 		{
    21. 			return const_iterator(_head);
    22. 		}
    23.  
    24. 		iterator begin()
    25. 		{
    26. 			return iterator(_head->_next);
    27. 			//return _head->_next;
    28. 		}
    29.  
    30. 		iterator end()
    31. 		{
    32. 			return iterator(_head);
    33. 		}
    34.  
    35. 		const_reverse_iterator rbegin() const
    36. 		{
    37. 			// list_node*
    38. 			return const_reverse_iterator(end());
    39. 		}
    40.  
    41. 		const_reverse_iterator rend() const
    42. 		{
    43. 			return const_reverse_iterator(begin());
    44. 		}
    45.  
    46. 		reverse_iterator rbegin()
    47. 		{
    48. 			return reverse_iterator(end());
    49. 		}
    50.  
    51. 		reverse_iterator rend()
    52. 		{
    53. 			return reverse_iterator(begin());
    54. 		}
    55.         ……
    56. 对list中反向迭代器的测试：
    57. void test_list7()
    58. 	{
    59. 		list<int> lt;
    60. 		lt.push_back(1);
    61. 		lt.push_back(2);
    62. 		lt.push_back(2);
    63. 		lt.push_back(3);
    64. 		lt.push_back(4);
    65.  
    66. 		list<int>::reverse_iterator rit = lt.rbegin();
    67. 		while (rit != lt.rend())
    68. 		{
    69. 			cout << *rit << " ";
    70. 			++rit;
    71. 		}
    72. 		cout << endl;
    73. 	}

    七.typename

    类模板模板虚拟类型没有实例化之前不能去他里面找内嵌定义的类型
    类模板没有实例化，找出来也是虚拟类型，后期无法处理
    T&
    typename告诉编译器后面这一串是一个类型，等Iterator实例化以后,
    你再去他里面去找这个内嵌类型

  • 相关阅读:
    【前端缓存】localStorage是同步还是异步的？为什么？
    5.2 Ajax 数据爬取实战
    国际经济学 简答计算
    35岁危机来临前，程序员如何未雨绸缪？
    共识算法-Mencius详解
    发送QQ邮件
    Linux：进程（二）
    ansible镜像构建使用
    Swin Transformer：最佳论文，准确率和性能双佳的视觉Transformer | ICCV 2021
    堆优化迪氏最短单源路径原理及C++实现
  • 原文地址：https://blog.csdn.net/zhang_si_hang/article/details/126067468