有没有相当于C ++中python的基于范围的enumerate
循环?我会想象这样的事情。
enumerateLoop (auto counter, auto el, container) {
charges.at(counter) = el[0];
aa.at(counter) = el[1];
}
可以使用模板或宏来完成吗?
我知道我可以使用旧学校循环并迭代直到我到达container.size()
。但我很感兴趣如何使用模板或宏来解决这个问题。
编辑
在评论中提示后,我使用了增强迭代器。我使用C ++ 14获得了另一个有效的解决方案。
template <typename... T>
auto zip(const T &... containers) -> boost::iterator_range<boost::zip_iterator<
decltype(boost::make_tuple(std::begin(containers)...))>> {
auto zip_begin =
boost::make_zip_iterator(boost::make_tuple(std::begin(containers)...));
auto zip_end =
boost::make_zip_iterator(boost::make_tuple(std::end(containers)...));
return boost::make_iterator_range(zip_begin, zip_end);
}
template <typename T>
auto enumerate(const T &container) {
return zip(boost::counting_range(0, static_cast<int>(container.size())),
container);
}
我曾经为此写过一些东西。
本质上,您需要包装迭代器并赋予它对语义。
AFAIK,语言中没有这样的内容。而且我认为也没有提升。你几乎不得不自己动手。
// Wraps a forward-iterator to produce {value, index} pairs, similar to
// python's enumerate()
template <typename Iterator>
struct EnumerateIterator {
private:
Iterator current;
Iterator last;
size_t index;
bool atEnd;
public:
typedef decltype(*std::declval<Iterator>()) IteratorValue;
typedef pair<IteratorValue const&, size_t> value_type;
EnumerateIterator()
: index(0), atEnd(true) {}
EnumerateIterator(Iterator begin, Iterator end)
: current(begin), last(end), index(0) {
atEnd = current == last;
}
EnumerateIterator begin() const {
return *this;
}
EnumerateIterator end() const {
return EnumerateIterator();
}
EnumerateIterator operator++() {
if (!atEnd) {
++current;
++index;
atEnd = current == last;
}
return *this;
}
value_type operator*() const {
return {*current, index};
}
bool operator==(EnumerateIterator const& rhs) const {
return
(atEnd && rhs.atEnd) ||
(!atEnd && !rhs.atEnd && current == rhs.current && last == rhs.last);
}
bool operator!=(EnumerateIterator const& rhs) const {
return !(*this == rhs);
}
explicit operator bool() const {
return !atEnd;
}
};
template<typename Iterable>
EnumerateIterator<decltype(std::declval<Iterable>().begin())> enumerateIterator(Iterable& list) {
return EnumerateIterator<decltype(std::declval<Iterable>().begin())>(list.begin(), list.end());
}
template<typename ResultContainer, typename Iterable>
ResultContainer enumerateConstruct(Iterable&& list) {
ResultContainer res;
for (auto el : enumerateIterator(list))
res.push_back(move(el));
return res;
}
自C以来,多个变量的枚举一直是一个习惯用法。唯一的复杂因素是你不能在for循环的初始化器中声明这两个变量。
int index;
for (auto p = container.begin(), index = 0; p != container.end(); ++p, ++index)
我不认为它比那更简单(或更强大)。
有一个预先C ++ 11解决方案来推动这个:boost.range.indexed。不幸的是,它不适用于基于C ++ 11范围的for循环,只有旧式详细循环。但是使用C ++ 17它应该变得(几乎)使用structured bindings在python中一样容易
然后应该可以实现这样的工作:
for (auto& [n,x] : enumerate(vec)) x = n;
所以,还有一点等待;)
您还可以更优雅地使用自C ++ 11以来可用的自动范围:
int i = 0;
for (auto& el : container){
charges.at(counter) = el[0];
aa.at(counter) = el[1];
++i;
}
不过,你仍然需要手工计算i
。
这是一个基于宏的解决方案,在简单性,编译时间和代码生成质量方面可能胜过大多数其他解决方案:
#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 !
Boost :: Range支持这个as of 1.56。
#include <boost/range/adaptor/indexed.hpp>
#include <boost/assign.hpp>
#include <iterator>
#include <iostream>
#include <vector>
int main(int argc, const char* argv[])
{
using namespace boost::assign;
using namespace boost::adaptors;
std::vector<int> input;
input += 10,20,30,40,50,60,70,80,90;
// for (const auto& element : index(input, 0)) // function version
for (const auto& element : input | indexed(0))
{
std::cout << "Element = " << element.value()
<< " Index = " << element.index()
<< std::endl;
}
return 0;
}