devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++中把Lambda 表达式作为参数传递给模板函数。

作者：AllinToyou | 2024-05-01 15:59:17

赞

踩

C++中把Lambda 表达式作为参数传递给模板函数。

例子：

  1.  
  2. template<class fun>
  3. void mytest(fun f)
  4. {
  5.     _string s1 = "abc";
  6.     _string s2 = "abc";
  7.  
  8.     if (f(s1, s2))
  9.     {
  10.         std::cout << "相等。\n";
  11.     }
  12.      
  13. }
  14.  
  15.  
  16. int main()
  17. {
  18.   
  19.     mytest([](const _string s1, const _string& s2) { return s1 == s2; });
  20.  
  21.  
  22.     return 0;
  23.      
  24. }

输出：

下面是模拟C++标准库的应用：

  1. #include "X:\Work\Share\CCode\CPlatform\MathExt\_MathExt_out.h"
  2.  
  3. using namespace lf;
  4. using namespace std;
  5.  
  6.  
  7.  
  8.  
  9. int main()
  10. {
  11.     std::string  s1 = "abcd1111";
  12.  
  13.     s1.erase(std::find_if(s1.rbegin(), s1.rend(), [](char ch) { return ch != '1'; }).base(), s1.end());
  14.  
  15.     _string s2 = "abcd1111";
  16.  
  17.     s2.std_erase(lf::_find_if(s2.std_rbegin(), s2.std_rend(), [](char ch) { return ch != '1'; }).std_base(), s2.end());
  18.  
  19.  
  20.     std::cout  << "s1=" << s1 << "\n";
  21.  
  22.     _pcn(s2);
  23.      
  24. }

输出：

代码：

  1. /*******************************************************************************************
  2. 文件名							： _xutility.h
  4. 作者								： 李锋
  6. 功能								： 模拟 <xutility>
  8. 创建时间							： 2024年04月21日
  10. 最后一次修改时间				    :  2024年04月21日
  11. ********************************************************************************************/
  12. #pragma once;
  13. #include "_Macro.h"
  14.  
  15. _LF_BEGIN_
  16.  
  17. /*
  18. _EXPORT_STD template <class _Category, class _Ty, class _Diff = ptrdiff_t, class _Pointer = _Ty*,
  19.     class _Reference = _Ty&>
  20. struct _CXX17_DEPRECATE_ITERATOR_BASE_CLASS iterator { // base type for iterator classes
  21.     using iterator_category = _Category; //表示迭代器的类别，例如输入、输出、前向、双向或随机访问等。
  22.     using value_type        = _Ty; //表示迭代器所指向元素的类型。
  23.     using difference_type   = _Diff; //表示迭代器之间的差值类型，默认为ptrdiff_t。
  24.     using pointer           = _Pointer; //表示迭代器所指向元素的指针类型。
  25.     using reference         = _Reference; //表示迭代器所指向元素的引用类型。
  26. };
  29. _CXX17_DEPRECATE_ITERATOR_BASE_CLASS是一个宏定义，用于在C++17中标记迭代器基类
  30. （如std::iterator）的弃用。这个宏定义通常用于告知开发者，该迭代器基类在未来的版
  31. 本中可能会被移除或更改，建议使用其他替代方案。
  35. _EXPORT_STD是一个宏定义，通常用于在标准库的头文件中。它的作用是在编译时将一些符号标记为导出（export），
  36. 以便在其他模块中使用。这样做的目的是避免在链接时出现重复定义的错误。然而，这个宏在C++17中已经被移除，
  37. 因为它与模块化的支持有关，而模块化在C++17中并未完全实现。
  38. */
  39.  
  40.  
  41. /// <summary>
  42. /// 
  43. /// </summary>
  44. /// <typeparam name="T"></typeparam>
  45. /// <typeparam name="Isbackward"></typeparam>
  46. /// <typeparam name="Step"></typeparam>
  47. /// 创建时间：2024-04-21    最后一次修改时间：2024-04-21 
  48. template <typename T, size_t Step = 1, bool Isbackward = true>
  49. class _iterator_base { 
  50. public:
  51.     T* _pt;
  52. public:
  53.     inline _iterator_base(const T* pt) : _pt((T*)pt) {}
  54. public:
  55.  
  56.     /// <summary>
  57.     /// 类型转换
  58.     /// </summary>
  59.     inline operator const T* () const { return _pt; }
  60.  
  61.     /// <summary>
  62.     /// 前置加加
  63.     /// </summary>
  64.     /// <returns></returns>
  65.     _iterator_base& operator++() {//效率高
  66.         if (Isbackward)
  67.             _pt = _pt + Step;
  68.         else
  69.             _pt = _pt - Step;
  70.  
  71.         return *this;
  72.     }
  73.     
  74.     /// <summary>
  75.     /// 后置加加
  76.     /// </summary>
  77.     /// <param name=""></param>
  78.     /// <returns></returns>
  79.     _iterator_base operator++(int) {   
  80.         _iterator_base oldvalue = *this;
  81.         if (Isbackward)
  82.             _pt = _pt + Step;
  83.         else
  84.             _pt = _pt - Step;
  85.  
  86.         return oldvalue;
  87.     }
  88.  
  89.  
  90.     /// <summary>
  91.     /// 前置减减
  92.     /// </summary>
  93.     /// <returns></returns>
  94.     inline _iterator_base& operator--() {
  95.         if (Isbackward)
  96.             _pt = _pt - Step;
  97.         else
  98.             _pt = _pt + Step;
  99.  
  100.         return *this;
  101.     }
  102.  
  103.     /// <summary>
  104.     /// 后置减减
  105.     /// </summary>
  106.     /// <param name=""></param>
  107.     /// <returns></returns>
  108.     _iterator_base operator--(int)
  109.     {
  110.         _iterator_base oldvalue = *this;
  111.  
  112.         if (Isbackward)
  113.             _pt = _pt - Step;
  114.         else
  115.             _pt = _pt + Step;
  116.     }
  117.  
  118.     inline bool operator==(const _iterator_base& right) {
  119.         return _pt == right._pt;
  120.     }
  121.  
  122.     inline bool operator<(const _iterator_base& right) {
  123.         if (Isbackward)
  124.             return _pt < right._pt;
  125.         else
  126.             return _pt > right._pt;        
  127.     }
  128.  
  129.  
  130.     inline bool operator<=(const _iterator_base& right) {
  131.         if (Isbackward)
  132.             return _pt <= right._pt;
  133.         else
  134.             return _pt >= right._pt;
  135.     }
  136.  
  137.  
  138.     inline bool operator>(const _iterator_base& right) {
  139.         if (Isbackward)
  140.             return _pt > right._pt;
  141.         else
  142.             return _pt < right._pt;
  143.     }
  144.  
  145.     
  146.  
  147.     // 解引用操作符重载
  148.     inline const T& operator*() const{  return *_pt;   }
  149.  
  150.     /*
  151.     // 获取原始指针的操作符重载
  152.     T* operator->() const {
  153.         return _pt;
  154.     }
  155.     */
  156.  
  157.     inline const T* std_base() { return _pt; }
  158. };
  159.  
  160. template <typename T>
  161. class _iterator : public _iterator_base<T,1,true>
  162. {
  163. public:
  164.     inline _iterator(const T* pt) : _iterator_base<T, 1, true>(pt) {}
  165. };
  166.  
  167. template <typename T>
  168. class _reverse_iterator : public _iterator_base<T, 1, false>
  169. {
  170. public:
  171.  
  172.     inline _reverse_iterator(const T* pt) : _iterator_base<T, 1, false>(pt) {  }     
  173. };
  174.  
  175.  
  176.  
  177.  
  178. /// <summary>
  179. /// 模拟std::find_if
  180. /// </summary>
  181. /// <typeparam name="T"></typeparam>
  182. /// <typeparam name="fun"></typeparam>
  183. /// <param name="first"></param>
  184. /// <param name="last"></param>
  185. /// <param name="pred"></param>
  186. /// <returns></returns>
  187. /// 创建时间：2024-04-21    最后一次修改时间：2024-04-22 
  188. template <class T, class fun>
  189. _reverse_iterator<T> _find_if(const _reverse_iterator<T>& first,
  190.     const _reverse_iterator<T>& last, fun pred) {
  191.  
  192.     /*  用法
  193.     std::string s1 = "0abc023030000";
  196.     s1.erase(std::find_if(s1.rbegin(), s1.rend(),
  197.         [](char ch) { return ch != '0'; }).base(), s1.end());
  199.     std::cout << "s1=" << s1 << "\n";
  201.     _string s2 = _t("0abc023030000");
  203.     s2.std_erase(lf::_find_if(s2.std_rbegin(), s2.std_rend(),
  204.         [](wchar_t ch) { return ch != _t('0'); }).std_base(), s2.std_end());
  206.     std::wcout << _t("s2=") << s2 << _t("\n");
  208.     */
  209.  
  210.     _reverse_iterator<T> itStart = first;
  211.     ++itStart;
  212.  
  213.     for (; itStart <= last; itStart++) {
  214.  
  215.         if (pred(*itStart)) {
  216.             return itStart + 1; //符合条件字符串的下一位置。
  217.         }
  218.     }
  219.     return last;
  220. }
  221.  
  222. _LF_END_

_string中的代码：

  1. 	/// <summary>
  2. 	/// 模拟std::string::erase
  3. 	/// </summary>
  4. 	/// <param name="first"></param>
  5. 	/// <param name="last"></param>
  6. 	/// <returns></returns>
  7. 	/// 创建时间： 2024-04-21      最后一次修改时间：2024-04-22
  8. 	_Str<T>& std_erase(const _iterator<T>& first, const _iterator<T>& last) {
  9. 		/*
  10. 		    std::string s1 = "0abc023030000";
  12. 			s1.erase(std::find_if(s1.rbegin(), s1.rend(),
  13. 				[](char ch) { return ch != '0'; }).base(), s1.end());
  15. 			std::cout << "s1=" << s1 << "\n";
  17. 			_string s2 = _t("0abc023030000");
  19. 			s2.std_erase(lf::_find_if(s2.std_rbegin(), s2.std_rend(),
  20. 				[](wchar_t ch) { return ch != _t('0'); }).std_base(), s2.std_end());
  22. 			std::wcout << _t("s2=") << s2 << _t("\n");
  23. 		*/
  24. 	 
  25. 		_Str<T> tmp(_t(""), _nLength);
  26. 		 
  27. 		const T* pf = first;
  28.  
  29. 		T* pl = (T*)(const T*)last;
  30.  
  31. 		int n = pf - _pData;
  32.  
  33.  
  34. 		//拷贝前半部分
  35. 		if (n > 0){
  36. 			for (int i = 0; i < n; ++i){
  37. 				tmp.Add(*(_pData + i));
  38. 			}
  39. 		}
  40.  
  41. 		++pl;
  42.  
  43. 		//拷贝后半部分
  44. 		while (*pl)	{
  45. 			tmp.Add(*pl);
  46. 			++pl;
  47. 		}
  48. 		
  49. 		//清除字符，注意，在这里不要清除内存
  50. 		this->Clear();
  51. 		this->Add(tmp); //拷贝进来
  52. 		 
  53. 		return *this;
  54. 	}

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/519598
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号