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

例子：

template<class fun>
void mytest(fun f)
{
    _string s1 = "abc";
    _string s2 = "abc";

    if (f(s1, s2))
    {
        std::cout << "相等。\n";
    }
     
}
 

int main()
{
  
    mytest([](const _string s1, const _string& s2) { return s1 == s2; });


    return 0;
     
}

输出：

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

#include "X:\Work\Share\CCode\CPlatform\MathExt\_MathExt_out.h"
 
using namespace lf;
using namespace std;
 

 

int main()
{
    std::string  s1 = "abcd1111";

    s1.erase(std::find_if(s1.rbegin(), s1.rend(), [](char ch) { return ch != '1'; }).base(), s1.end());

    _string s2 = "abcd1111";

    s2.std_erase(lf::_find_if(s2.std_rbegin(), s2.std_rend(), [](char ch) { return ch != '1'; }).std_base(), s2.end());


    std::cout  << "s1=" << s1 << "\n";

    _pcn(s2);
     
}

输出：

代码：

/*******************************************************************************************
文件名							： _xutility.h

作者								： 李锋

功能								： 模拟 <xutility>

创建时间							： 2024年04月21日

最后一次修改时间				    :  2024年04月21日
********************************************************************************************/
#pragma once;
#include "_Macro.h"

_LF_BEGIN_

/*
_EXPORT_STD template <class _Category, class _Ty, class _Diff = ptrdiff_t, class _Pointer = _Ty*,
    class _Reference = _Ty&>
struct _CXX17_DEPRECATE_ITERATOR_BASE_CLASS iterator { // base type for iterator classes
    using iterator_category = _Category; //表示迭代器的类别，例如输入、输出、前向、双向或随机访问等。
    using value_type        = _Ty; //表示迭代器所指向元素的类型。
    using difference_type   = _Diff; //表示迭代器之间的差值类型，默认为ptrdiff_t。
    using pointer           = _Pointer; //表示迭代器所指向元素的指针类型。
    using reference         = _Reference; //表示迭代器所指向元素的引用类型。
};


_CXX17_DEPRECATE_ITERATOR_BASE_CLASS是一个宏定义，用于在C++17中标记迭代器基类
（如std::iterator）的弃用。这个宏定义通常用于告知开发者，该迭代器基类在未来的版
本中可能会被移除或更改，建议使用其他替代方案。



_EXPORT_STD是一个宏定义，通常用于在标准库的头文件中。它的作用是在编译时将一些符号标记为导出（export），
以便在其他模块中使用。这样做的目的是避免在链接时出现重复定义的错误。然而，这个宏在C++17中已经被移除，
因为它与模块化的支持有关，而模块化在C++17中并未完全实现。
*/


/// <summary>
/// 
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="Isbackward"></typeparam>
/// <typeparam name="Step"></typeparam>
/// 创建时间：2024-04-21    最后一次修改时间：2024-04-21 
template <typename T, size_t Step = 1, bool Isbackward = true>
class _iterator_base { 
public:
    T* _pt;
public:
    inline _iterator_base(const T* pt) : _pt((T*)pt) {}
public:

    /// <summary>
    /// 类型转换
    /// </summary>
    inline operator const T* () const { return _pt; }

    /// <summary>
    /// 前置加加
    /// </summary>
    /// <returns></returns>
    _iterator_base& operator++() {//效率高
        if (Isbackward)
            _pt = _pt + Step;
        else
            _pt = _pt - Step;

        return *this;
    }
    
    /// <summary>
    /// 后置加加
    /// </summary>
    /// <param name=""></param>
    /// <returns></returns>
    _iterator_base operator++(int) {   
        _iterator_base oldvalue = *this;
        if (Isbackward)
            _pt = _pt + Step;
        else
            _pt = _pt - Step;

        return oldvalue;
    }
 
 
    /// <summary>
    /// 前置减减
    /// </summary>
    /// <returns></returns>
    inline _iterator_base& operator--() {
        if (Isbackward)
            _pt = _pt - Step;
        else
            _pt = _pt + Step;

        return *this;
    }

    /// <summary>
    /// 后置减减
    /// </summary>
    /// <param name=""></param>
    /// <returns></returns>
    _iterator_base operator--(int)
    {
        _iterator_base oldvalue = *this;

        if (Isbackward)
            _pt = _pt - Step;
        else
            _pt = _pt + Step;
    }

    inline bool operator==(const _iterator_base& right) {
        return _pt == right._pt;
    }

    inline bool operator<(const _iterator_base& right) {
        if (Isbackward)
            return _pt < right._pt;
        else
            return _pt > right._pt;        
    }


    inline bool operator<=(const _iterator_base& right) {
        if (Isbackward)
            return _pt <= right._pt;
        else
            return _pt >= right._pt;
    }


    inline bool operator>(const _iterator_base& right) {
        if (Isbackward)
            return _pt > right._pt;
        else
            return _pt < right._pt;
    }

    

    // 解引用操作符重载
    inline const T& operator*() const{  return *_pt;   }

    /*
    // 获取原始指针的操作符重载
    T* operator->() const {
        return _pt;
    }
    */

    inline const T* std_base() { return _pt; }
};

template <typename T>
class _iterator : public _iterator_base<T,1,true>
{
public:
    inline _iterator(const T* pt) : _iterator_base<T, 1, true>(pt) {}
};

template <typename T>
class _reverse_iterator : public _iterator_base<T, 1, false>
{
public:

    inline _reverse_iterator(const T* pt) : _iterator_base<T, 1, false>(pt) {  }     
};




/// <summary>
/// 模拟std::find_if
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="fun"></typeparam>
/// <param name="first"></param>
/// <param name="last"></param>
/// <param name="pred"></param>
/// <returns></returns>
/// 创建时间：2024-04-21    最后一次修改时间：2024-04-22 
template <class T, class fun>
_reverse_iterator<T> _find_if(const _reverse_iterator<T>& first,
    const _reverse_iterator<T>& last, fun pred) {

    /*  用法
    std::string s1 = "0abc023030000";


    s1.erase(std::find_if(s1.rbegin(), s1.rend(),
        [](char ch) { return ch != '0'; }).base(), s1.end());

    std::cout << "s1=" << s1 << "\n";

    _string s2 = _t("0abc023030000");

    s2.std_erase(lf::_find_if(s2.std_rbegin(), s2.std_rend(),
        [](wchar_t ch) { return ch != _t('0'); }).std_base(), s2.std_end());

    std::wcout << _t("s2=") << s2 << _t("\n");

    */

    _reverse_iterator<T> itStart = first;
    ++itStart;

    for (; itStart <= last; itStart++) {

        if (pred(*itStart)) {
            return itStart + 1; //符合条件字符串的下一位置。
        }
    }
    return last;
}

_LF_END_

_string中的代码：

	/// <summary>
	/// 模拟std::string::erase
	/// </summary>
	/// <param name="first"></param>
	/// <param name="last"></param>
	/// <returns></returns>
	/// 创建时间： 2024-04-21      最后一次修改时间：2024-04-22
	_Str<T>& std_erase(const _iterator<T>& first, const _iterator<T>& last) {
		/*
		    std::string s1 = "0abc023030000";

			s1.erase(std::find_if(s1.rbegin(), s1.rend(),
				[](char ch) { return ch != '0'; }).base(), s1.end());

			std::cout << "s1=" << s1 << "\n";

			_string s2 = _t("0abc023030000");

			s2.std_erase(lf::_find_if(s2.std_rbegin(), s2.std_rend(),
				[](wchar_t ch) { return ch != _t('0'); }).std_base(), s2.std_end());

			std::wcout << _t("s2=") << s2 << _t("\n");
		*/
	 
		_Str<T> tmp(_t(""), _nLength);
		 
		const T* pf = first;

		T* pl = (T*)(const T*)last;

		int n = pf - _pData;


		//拷贝前半部分
		if (n > 0){
			for (int i = 0; i < n; ++i){
				tmp.Add(*(_pData + i));
			}
		}

		++pl;

		//拷贝后半部分
		while (*pl)	{
			tmp.Add(*pl);
			++pl;
		}
		
		//清除字符，注意，在这里不要清除内存
		this->Clear();
		this->Add(tmp); //拷贝进来
		 
		return *this;
	}