假设我有以下代码：
vector<int> list;
for(auto& elem:list) {
int i = elem;
}
我可以elem在不维护单独的迭代器的情况下找到向量中的位置吗？
问问题
53998 次
12 回答
66
是的，你可以，只是需要一些按摩；）
诀窍是使用组合：不是直接迭代容器，而是沿途使用索引“压缩”它。
专用拉链代码：
template <typename T>
struct iterator_extractor { typedef typename T::iterator type; };
template <typename T>
struct iterator_extractor<T const> { typedef typename T::const_iterator type; };
template <typename T>
class Indexer {
public:
class iterator {
typedef typename iterator_extractor<T>::type inner_iterator;
typedef typename std::iterator_traits<inner_iterator>::reference inner_reference;
public:
typedef std::pair<size_t, inner_reference> reference;
iterator(inner_iterator it): _pos(0), _it(it) {}
reference operator*() const { return reference(_pos, *_it); }
iterator& operator++() { ++_pos; ++_it; return *this; }
iterator operator++(int) { iterator tmp(*this); ++*this; return tmp; }
bool operator==(iterator const& it) const { return _it == it._it; }
bool operator!=(iterator const& it) const { return !(*this == it); }
private:
size_t _pos;
inner_iterator _it;
};
Indexer(T& t): _container(t) {}
iterator begin() const { return iterator(_container.begin()); }
iterator end() const { return iterator(_container.end()); }
private:
T& _container;
}; // class Indexer
template <typename T>
Indexer<T> index(T& t) { return Indexer<T>(t); }
并使用它：
#include <iostream>
#include <iterator>
#include <limits>
#include <vector>
// Zipper code here
int main() {
std::vector<int> v{1, 2, 3, 4, 5, 6, 7, 8, 9};
for (auto p: index(v)) {
std::cout << p.first << ": " << p.second << "\n";
}
}
你可以在ideone看到它，虽然它缺乏 for-range 循环支持，所以它不那么漂亮。
编辑：
只是记得我应该更频繁地检查 Boost.Range。不幸的是没有zip范围，但我确实找到了一颗珍珠：boost::adaptors::indexed。但是，它需要访问迭代器才能提取索引。耻辱：x
否则，使用counting_range和泛型zip我相信它可以做一些有趣的事情......
在理想的世界里，我会想象：
int main() {
std::vector<int> v{1, 2, 3, 4, 5, 6, 7, 8, 9};
for (auto tuple: zip(iota(0), v)) {
std::cout << tuple.at<0>() << ": " << tuple.at<1>() << "\n";
}
}
zip自动创建一个视图作为引用元组的范围，并简单iota(0)地创建一个“假”范围，该范围从无穷大开始0并只计数无穷大（或者好吧，它的类型的最大值......）。
于 2012-06-09T16:20:33.850 回答
31
jrok 是对的：基于范围的 for 循环不是为此目的而设计的。
但是，在您的情况下，可以使用指针算法来计算它，因为vector它的元素是连续存储的 (*)
vector<int> list;
for(auto& elem:list) {
int i = elem;
int pos = &elem-&list[0]; // pos contains the position in the vector
// also a &-operator overload proof alternative (thanks to ildjarn) :
// int pos = addressof(elem)-addressof(list[0]);
}
但这显然是一种不好的做法，因为它会混淆代码并使其更加脆弱（如果有人更改容器类型、重载&运算符或将 'auto&' 替换为 'auto'，它很容易中断。祝你调试好运！）
注意：C++03 中的向量以及 C++11 标准中的数组和字符串保证了连续性。
于 2012-06-09T16:01:54.863 回答
20
不，你不能（至少，不费力气）。如果您需要元素的位置，则不应使用基于范围的 for。请记住，它只是最常见情况的便利工具：为每个元素执行一些代码。在需要元素位置的不太常见的情况下，您必须使用不太方便的常规for循环。
于 2012-06-09T16:00:54.940 回答
17
根据@Matthieu 的回答，使用提到的boost::adaptors::indexed有一个非常优雅的解决方案：
std::vector<std::string> strings{10, "Hello"};
int main(){
strings[5] = "World";
for(auto const& el: strings| boost::adaptors::indexed(0))
std::cout << el.index() << ": " << el.value() << std::endl;
}
这很像提到的“理想世界解决方案”，语法漂亮且简洁。请注意，el在这种情况下的类型类似于boost::foobar<const std::string&, int>，因此它在那里处理引用并且不执行复制。它甚至非常高效：https ://godbolt.org/g/e4LMnJ （代码相当于保留一个自己的计数器变量，它尽可能好）
为了完整起见，替代方案：
size_t i = 0;
for(auto const& el: strings) {
std::cout << i << ": " << el << std::endl;
++i;
}
或者使用向量的连续属性：
for(auto const& el: strings) {
size_t i = &el - &strings.front();
std::cout << i << ": " << el << std::endl;
}
第一个生成与 boost 适配器版本相同的代码（最佳），最后一个指令更长：https ://godbolt.org/g/nEG8f9
注意：如果你只想知道，如果你有最后一个元素，你可以使用：
for(auto const& el: strings) {
bool isLast = &el == &strings.back();
std::cout << isLast << ": " << el << std::endl;
}
这适用于每个标准容器，但必须使用auto&/ （与上面相同），但无论如何都建议这样做。auto const&根据输入，这也可能非常快（尤其是当编译器知道向量的大小时）
替换&foobystd::addressof(foo)以确保通用代码的安全。
于 2018-07-20T08:44:03.953 回答
11
如果你有一个支持 C++14 的编译器，你可以用函数式的方式来做：
#include <iostream>
#include <string>
#include <vector>
#include <functional>
template<typename T>
void for_enum(T& container, std::function<void(int, typename T::value_type&)> op)
{
int idx = 0;
for(auto& value : container)
op(idx++, value);
}
int main()
{
std::vector<std::string> sv {"hi", "there"};
for_enum(sv, [](auto i, auto v) {
std::cout << i << " " << v << std::endl;
});
}
适用于 clang 3.4 和 gcc 4.9（不适用于 4.8）；对于两者都需要设置-std=c++1y。您需要 c++14 的原因是autolambda 函数中的参数。
于 2014-07-03T17:14:06.810 回答
6
有一种非常简单的方法可以做到这一点
vector<int> list;
for(auto& elem:list) {
int i = (&elem-&*(list.begin()));
}
i您需要的索引在哪里。
这利用了C++ 向量总是连续的这一事实。
于 2017-04-15T07:06:20.083 回答
6
如果您坚持使用基于范围的 for 并了解索引，则维护索引非常简单，如下所示。我认为基于范围的 for 循环没有更清洁/更简单的解决方案。但真的为什么不使用标准 for(;;) 呢？这可能会使您的意图和代码最清晰。
vector<int> list;
int idx = 0;
for(auto& elem:list) {
int i = elem;
//TODO whatever made you want the idx
++idx;
}
于 2016-08-17T15:21:24.047 回答
3
这是一个使用 c++20 的非常漂亮的解决方案：
#include <array>
#include <iostream>
#include <ranges>
template<typename T>
struct EnumeratedElement {
std::size_t index;
T& element;
};
auto enumerate(std::ranges::range auto& range)
-> std::ranges::view auto
{
return range | std::views::transform(
[i = std::size_t{}](auto& element) mutable {
return EnumeratedElement{i++, element};
}
);
}
auto main() -> int {
auto const elements = std::array{3, 1, 4, 1, 5, 9, 2};
for (auto const [index, element] : enumerate(elements)) {
std::cout << "Element " << index << ": " << element << '\n';
}
}
这里使用的主要特性是 c++20 范围、c++20 概念、c++11 可变 lambda、c++14 lambda 捕获初始化程序和 c++17 结构化绑定。有关任何这些主题的信息，请参阅 cppreference.com。
请注意，element在结构化绑定中实际上是引用而不是元素的副本（在这里并不重要）。这是因为 only 周围的任何限定符auto都会影响从中提取字段的临时对象，而不是字段本身。
生成的代码与由此生成的代码相同（至少由 gcc 10.2 生成）：
#include <array>
#include <iostream>
#include <ranges>
auto main() -> int {
auto const elements = std::array{3, 1, 4, 1, 5, 9, 2};
for (auto index = std::size_t{}; auto& element : elements) {
std::cout << "Element " << index << ": " << element << '\n';
index++;
}
}
于 2020-10-10T11:24:16.400 回答
2
我从您的评论中了解到，您想知道索引的一个原因是要知道该元素是否是序列中的第一个/最后一个。如果是这样，你可以这样做
for(auto& elem:list) {
// loop code ...
if(&elem == &*std::begin(list)){ ... special code for first element ... }
if(&elem == &*std::prev(std::end(list))){ ... special code for last element ... }
// if(&elem == &*std::rbegin(list)){... (C++14 only) special code for last element ...}
// loop code ...
}
编辑：例如，这将打印一个跳过最后一个元素中的分隔符的容器。适用于我能想象到的大多数容器（包括数组），（在线演示http://coliru.stacked-crooked.com/a/9bdce059abd87f91）：
#include <iostream>
#include <vector>
#include <list>
#include <set>
using namespace std;
template<class Container>
void print(Container const& c){
for(auto& x:c){
std::cout << x;
if(&x != &*std::prev(std::end(c))) std::cout << ", "; // special code for last element
}
std::cout << std::endl;
}
int main() {
std::vector<double> v{1.,2.,3.};
print(v); // prints 1,2,3
std::list<double> l{1.,2.,3.};
print(l); // prints 1,2,3
std::initializer_list<double> i{1.,2.,3.};
print(i); // prints 1,2,3
std::set<double> s{1.,2.,3.};
print(s); // print 1,2,3
double a[3] = {1.,2.,3.}; // works for C-arrays as well
print(a); // print 1,2,3
}
于 2013-11-13T03:13:02.727 回答
1
如果您想避免在将索引变量设置为循环本地的同时编写辅助函数，您可以使用带有可变变量的 lambda。：
int main() {
std::vector<char> values = {'a', 'b', 'c'};
std::for_each(begin(values), end(values), [i = size_t{}] (auto x) mutable {
std::cout << i << ' ' << x << '\n';
++i;
});
}
于 2019-08-27T13:39:25.343 回答
0
这是一个基于宏的解决方案，它可能在简单性、编译时间和代码生成质量方面胜过大多数其他解决方案：
#include <iostream>
#define fori(i, ...) if(size_t i = -1) for(__VA_ARGS__) if(i++, true)
int main() {
fori(i, auto const & x : {"hello", "world", "!"}) {
std::cout << i << " " << x << std::endl;
}
}
结果：
$ g++ -o enumerate enumerate.cpp -std=c++11 && ./enumerate
0 hello
1 world
2 !
于 2019-01-12T03:53:00.200 回答