C++ C++；11等于或小于

代码：

#包括
#包括
#包括
使用名称空间std；
模板T pfind（T f、T e、C C）{
做{
对于（inti=1；f+i！=e；i++）
如果（c（*f，*f+i））
返回（f+i）；
}而（++f！=e）；
}
int main（）
{
向量VSTR={1,2,3,4,4,5,5}；
擦除（pfind（vstr.begin（），vstr.end（），equal_to（））；
用于（自动和itr:vstr）{
因此，亚历山德罗·特鲁齐在评论中提出了关键点

你确定你指的是
c（*f，*f+i）
而不是
c（*f，*（f+i））

但是也就是说，这可以更清楚地写为两个嵌套的for循环，并且具有更长的变量名

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

template<typename T, typename C> T pfind(T f, T e, C c){
    do{
        for (int i = 1; f + i != e; i++)
            if (c(*f, *f + i))
                return (f + i);
    } while (++f != e);
}

int main()
{
    vector<int>vstr = { 1, 2, 3, 4,4,5,5,5 };

    vstr.erase(pfind(vstr.begin(), vstr.end(),equal_to<int>()));
    for (auto&itr : vstr){
        cout << itr << " ";
    }
    getchar();
}

此外，在这两种情况下，我们都有可能返回结束指针。如果返回，那么我们将调用
vstr.erase（vstr.end（））
，这是一种未定义的行为。因此，您可能需要检查它

让我们谈谈特定警告的含义：
您在评论中说编译器报告了此警告：

template<typename T, typename C> T pfind(T begin, T end, C comparator){
    for (; begin != end; begin++)
        for (T iterator = std::next(begin); iterator != end; iterator++)
            if (comparator(*begin, *iterator))
                return begin;
    return end;
}

这意味着编译器无法确保通过代码的所有路径都以语句
return…；
结束。在您的情况下，在最简单的情况下，如果
begin==end
，则不会进入第一个循环，我们将在不到达
return…；
语句的情况下到达函数的末尾

在我发布的修复代码中，您可以看到，如果我们从未找到匹配项，我们将返回结束指针，这是报告不匹配项的常见方式。
因此，Alessandro Teruzzi在评论中指出了关键点

你确定你指的是
c（*f，*f+i）
而不是
c（*f，*（f+i））

但是也就是说，这可以更清楚地写为两个嵌套的for循环，并且具有更长的变量名

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

template<typename T, typename C> T pfind(T f, T e, C c){
    do{
        for (int i = 1; f + i != e; i++)
            if (c(*f, *f + i))
                return (f + i);
    } while (++f != e);
}

int main()
{
    vector<int>vstr = { 1, 2, 3, 4,4,5,5,5 };

    vstr.erase(pfind(vstr.begin(), vstr.end(),equal_to<int>()));
    for (auto&itr : vstr){
        cout << itr << " ";
    }
    getchar();
}

此外，在这两种情况下，我们都有可能返回结束指针。如果返回，那么我们将调用
vstr.erase（vstr.end（））
，这是一种未定义的行为。因此，您可能需要检查它

让我们谈谈特定警告的含义：
您在评论中说编译器报告了此警告：

template<typename T, typename C> T pfind(T begin, T end, C comparator){
    for (; begin != end; begin++)
        for (T iterator = std::next(begin); iterator != end; iterator++)
            if (comparator(*begin, *iterator))
                return begin;
    return end;
}

这意味着编译器无法确保通过代码的所有路径都以语句
return…；
结束。在您的情况下，在最简单的情况下，如果
begin==end
，则不会进入第一个循环，我们将在不到达
return…；
语句的情况下到达函数的末尾

在我发布的修复代码中，您可以看到，如果我们从未找到匹配项，我们将返回结束指针，这是报告不匹配项的常见方式。
因此，Alessandro Teruzzi在评论中指出了关键点

你确定你指的是
c（*f，*f+i）
而不是
c（*f，*（f+i））

但是也就是说，这可以更清楚地写为两个嵌套的for循环，并且具有更长的变量名

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

template<typename T, typename C> T pfind(T f, T e, C c){
    do{
        for (int i = 1; f + i != e; i++)
            if (c(*f, *f + i))
                return (f + i);
    } while (++f != e);
}

int main()
{
    vector<int>vstr = { 1, 2, 3, 4,4,5,5,5 };

    vstr.erase(pfind(vstr.begin(), vstr.end(),equal_to<int>()));
    for (auto&itr : vstr){
        cout << itr << " ";
    }
    getchar();
}

此外，在这两种情况下，我们都有可能返回结束指针。如果返回，那么我们将调用
vstr.erase（vstr.end（））
，这是一种未定义的行为。因此，您可能需要检查它

让我们谈谈特定警告的含义：
您在评论中说编译器报告了此警告：

template<typename T, typename C> T pfind(T begin, T end, C comparator){
    for (; begin != end; begin++)
        for (T iterator = std::next(begin); iterator != end; iterator++)
            if (comparator(*begin, *iterator))
                return begin;
    return end;
}

这意味着编译器无法确保通过代码的所有路径都以语句
return…；
结束。在您的情况下，在最简单的情况下，如果
begin==end
，则不会进入第一个循环，我们将在不到达
return…；
语句的情况下到达函数的末尾

在我发布的修复代码中，您可以看到，如果我们从未找到匹配项，我们将返回结束指针，这是报告不匹配项的常见方式。
因此，Alessandro Teruzzi在评论中指出了关键点

你确定你指的是
c（*f，*f+i）
而不是
c（*f，*（f+i））

但是也就是说，这可以更清楚地写为两个嵌套的for循环，并且具有更长的变量名

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

template<typename T, typename C> T pfind(T f, T e, C c){
    do{
        for (int i = 1; f + i != e; i++)
            if (c(*f, *f + i))
                return (f + i);
    } while (++f != e);
}

int main()
{
    vector<int>vstr = { 1, 2, 3, 4,4,5,5,5 };

    vstr.erase(pfind(vstr.begin(), vstr.end(),equal_to<int>()));
    for (auto&itr : vstr){
        cout << itr << " ";
    }
    getchar();
}

此外，在这两种情况下，我们都有可能返回结束指针。如果返回，那么我们将调用
vstr.erase（vstr.end（））
，这是一种未定义的行为。因此，您可能需要检查它

让我们谈谈特定警告的含义：
您在评论中说编译器报告了此警告：

template<typename T, typename C> T pfind(T begin, T end, C comparator){
    for (; begin != end; begin++)
        for (T iterator = std::next(begin); iterator != end; iterator++)
            if (comparator(*begin, *iterator))
                return begin;
    return end;
}

这意味着编译器无法确保通过代码的所有路径都以语句
return…；
结束。在您的情况下，在最简单的情况下，如果
begin==end
，则不会进入第一个循环，我们将在不到达
return…；
语句的情况下到达函数的末尾

在我发布的修复代码中，您可以看到，如果我们从未找到匹配项，我们将返回结束指针，这是报告不匹配的常见方式。
如果您注意了编译器警告，您就会知道函数失败的原因。当您将
std:：equal_to
作为比较谓词传递时，它没有找到match（由于代码中的错误）

如果未找到匹配项，则函数结束时不返回任何内容，这是未定义的行为。随后在调用
vector:：erase
时使用此不存在的返回值会导致崩溃


由于以下情况，您的代码找不到匹配项：

main.cpp:13:1: warning: control may reach end of non-void function [-Wreturn-type] 

首先取消对迭代器的引用，然后将
i
添加到该结果中

if (c(*f, *f + i))

然后在函数末尾添加一个return语句，用于未找到匹配项的情况

if (c(*f, *(f + i)))


最后，整个函数可以替换为搜索满足指定条件的两个相邻元素的范围。双参数版本使用
运算符==
执行比较，