C++ 使用std:：find_if时从传递给lambda的元素中获取迭代器

我试图简化接收迭代器的递归函数。在函数的某个地方，有必要在从迭代器到向量末尾的范围内搜索与给定条件匹配的元素。因此，我想我可以使用

find_if

，如下所示：

typedef std::vector<Foo> FooVec;
FooVec v;

int f(FooVec::iterator it) {
  /* ... */
  auto it2 = std::find_if(it, end(v),
      [](const Foo& foo) {
        auto foo_it = /* obtain the corresponding iterator for foo. */
        return f(foo_it) == 0;
      });
  /* ... */
}

typedef std:：vector FooVec；
FooVec v；
intf（FooVec:：iterator it）{
/* ... */
自动it2=std：：查找_if（it，end（v）），
[]（const Foo&Foo）{
auto foo_it=/*获取foo的相应迭代器*/
返回f（foo_it）==0；
});
/* ... */
}

---

但是lambda函数接收一个元素，而不是当前元素的迭代器，因此我不能轻易地再次调用

f

。我可以在

v

中搜索

foo

，以获得迭代器，但这样做效率很低。或者，我可以使用一个常规的

for

循环和迭代器。但是我想知道在这种情况下是否有可能使用

find_if

。

混乱，但是

v.begin（）+（&foo-&v.front（））

是指向

foo

的迭代器。请注意，这仅仅是因为

vector

具有连续存储：不要尝试使用

列表
或
deque
凌乱，但
v.begin（）+（&foo-&v.front（））
是指向
foo
的迭代器。请注意，这仅仅是因为
vector
具有连续存储：不要尝试使用
列表
或
deque
凌乱，但
v.begin（）+（&foo-&v.front（））
是指向
foo
的迭代器。请注意，这仅仅是因为
vector
具有连续存储：不要尝试使用
列表
或
deque
凌乱，但
v.begin（）+（&foo-&v.front（））
是指向
foo
的迭代器。请注意，这只适用于
vector
具有连续存储的情况：不要尝试使用
list
或
deque
如果我是你，我只会自己编写循环。（是的，我知道，我通常说使用算法，但这似乎是一个自己做更容易的情况）

未编译代码如下：

for ( auto iter = it; iter != end(v); ++iter )
{
// *iter is the value; iter is the iterator
// if you have to search to the end, you can use [iter, end(v))
}

适用于所有容器：vector、list、deque等。
如果我是你，我会自己编写循环。（是的，我知道，我通常说使用算法，但这似乎是一个自己做更容易的情况）

未编译代码如下：

for ( auto iter = it; iter != end(v); ++iter )
{
// *iter is the value; iter is the iterator
// if you have to search to the end, you can use [iter, end(v))
}

适用于所有容器：vector、list、deque等。
如果我是你，我会自己编写循环。（是的，我知道，我通常说使用算法，但这似乎是一个自己做更容易的情况）

未编译代码如下：

for ( auto iter = it; iter != end(v); ++iter )
{
// *iter is the value; iter is the iterator
// if you have to search to the end, you can use [iter, end(v))
}

适用于所有容器：vector、list、deque等。
如果我是你，我会自己编写循环。（是的，我知道，我通常说使用算法，但这似乎是一个自己做更容易的情况）

未编译代码如下：

for ( auto iter = it; iter != end(v); ++iter )
{
// *iter is the value; iter is the iterator
// if you have to search to the end, you can use [iter, end(v))
}

适用于所有容器：vector、list、deque等。
不清楚函数f的用途。去掉全局变量“v”（它可能不是全局变量，但用法类似），并将该v直接传递给递归函数（然后可以在lambda中捕获“v”）。我觉得这是XY问题的一个例子。在我的代码库中，我有一个适配器，它接受一个迭代器范围，并在该范围内的迭代器上生成一个范围（不包括end）。写起来并不难，但如果没有库（如
boost
或home-rolled），这有点乏味。我还有一个基于范围的
find_if
——介于两者之间，
auto it2=linear_search_if（迭代器）of（it，end（v）），[]（FooVec:：iterator foo）{/*blah*/} >我不认为这是一个答案，因为它没有描述如何编写<代码>线性搜索，如果< <代码> > <代码>迭代器>。不清楚函数的目的是什么？摆脱全局变量“V”（它可能不是全局的，但用法类似），并将该V直接传递给递归函数。（那么您可以在lambda中捕获“v”）。我觉得这是XY问题的一个例子。在我的代码库中，我有一个适配器，它接受一个迭代器范围，并在该范围内的迭代器上生成一个范围（不包括end）。编写它并不困难，但没有库（如
boost
或home-rolled）这有点乏味。我还有一个基于范围的
find_if
--介于两者之间，
auto it2=linear_search_if（iterators_of（it，end（v）），[]（FooVec:：iterator foo）{/*blah*/}我不认为这是一个答案，因为它不描述如何写<代码>线性搜索，如果< <代码> > <代码>迭代器> <代码>。不清楚函数的目的是什么？摆脱全局变量“V”（它可能不是全局的，但用法类似），并直接将该V传递给递归函数。（那么您可以在lambda中捕获“v”）。我觉得这是XY问题的一个例子。在我的代码库中，我有一个适配器，它接受一个迭代器范围，并在该范围内的迭代器上生成一个范围（不包括end）。编写它并不困难，但没有库（如
boost
或home-rolled）这有点乏味。我还有一个基于范围的
find_if
--介于两者之间，
auto it2=linear_search_if（iterators_of（it，end（v）），[]（FooVec:：iterator foo）{/*blah*/}我不认为这是一个答案，因为它不描述如何写<代码>线性搜索，如果< <代码> > <代码>迭代器> <代码>。不清楚函数的目的是什么？摆脱全局变量“V”（它可能不是全局的，但用法类似），并直接将该V传递给递归函数。（然后您可以在lambda中捕获“v”）。我觉得这是XY问题的一个例子。在我的代码库中，我有一个适配器，它接受迭代器范围，并生成