C ++ 11のSequence-Zip関数？
新しい範囲ベースのforループを使用すると、次のようなコードを記述できます。
for(auto x: Y) {}
どのIMOが巨大からの改善（例）
for(std::vector<int>::iterator x=Y.begin(); x!=Y.end(); ++x) {}
PythonのZip関数のように、2つの同時ループをループするために使用できますか？ Pythonに不慣れな人のために、コードは次のとおりです。
Y1 = [1,2,3]
Y2 = [4,5,6,7]
for x1,x2 in Zip(Y1,Y2):
print x1,x2
出力として与える(1,4) (2,5) (3,6)
警告：boost::Zip_iteratorおよびboost::combine現在、Boost 1.63.0（2016年12月26日）は、入力コンテナーの長さが同じでない場合、未定義の動作を引き起こします（終了後、クラッシュまたは反復する可能性があります）。
Boost 1.56.0（2014年8月7日）から se boost::combine （この関数は以前のバージョンに存在しますが、文書化されていません）：
#include <boost/range/combine.hpp>
#include <vector>
#include <list>
#include <string>
int main() {
std::vector<int> a {4, 5, 6};
double b[] = {7, 8, 9};
std::list<std::string> c {"a", "b", "c"};
for (auto tup : boost::combine(a, b, c, a)) { // <---
int x, w;
double y;
std::string z;
boost::tie(x, y, z, w) = tup;
printf("%d %g %s %d\n", x, y, z.c_str(), w);
}
}
これは印刷されます
4 7 a 4 5 8 b 5 6 9 c 6
以前のバージョンでは、次のように自分で範囲を定義できました。
#include <boost/iterator/Zip_iterator.hpp>
#include <boost/range.hpp>
template <typename... T>
auto Zip(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);
}
使い方は同じです。
boost::Zip_iteratorに基づいたソリューションを使用できます。コンテナへの参照を維持し、beginおよびendメンバー関数からZip_iteratorを返す偽のコンテナクラスを作成します。今、あなたは書くことができます
for (auto p: Zip(c1, c2)) { ... }
実装例（テストしてください）：
#include <iterator>
#include <boost/iterator/Zip_iterator.hpp>
template <typename C1, typename C2>
class Zip_container
{
C1* c1; C2* c2;
typedef boost::Tuple<
decltype(std::begin(*c1)),
decltype(std::begin(*c2))
> Tuple;
public:
Zip_container(C1& c1, C2& c2) : c1(&c1), c2(&c2) {}
typedef boost::Zip_iterator<Tuple> iterator;
iterator begin() const
{
return iterator(std::begin(*c1), std::begin(*c2));
}
iterator end() const
{
return iterator(std::end(*c1), std::end(*c2));
}
};
template <typename C1, typename C2>
Zip_container<C1, C2> Zip(C1& c1, C2& c2)
{
return Zip_container<C1, C2>(c1, c2);
}
読者への優れた演習として、可変長バージョンを残します。
見る - <redi/Zip.h> 範囲ベースZipで動作し、任意の数の範囲を受け入れるfor関数の場合、右辺値または左辺値、異なる長さを指定できます（反復は最短範囲の終わり）。
std::vector<int> vi{ 0, 2, 4 };
std::vector<std::string> vs{ "1", "3", "5", "7" };
for (auto i : redi::Zip(vi, vs))
std::cout << i.get<0>() << ' ' << i.get<1>() << ' ';
印刷0 1 2 3 4 5
退屈する前にこのZipを書いたのですが、boostを使用せず、c ++ stdlibのように見えるという点で他のZipとは異なるため、投稿することにしました。
template <typename Iterator>
void advance_all (Iterator & iterator) {
++iterator;
}
template <typename Iterator, typename ... Iterators>
void advance_all (Iterator & iterator, Iterators& ... iterators) {
++iterator;
advance_all(iterators...);
}
template <typename Function, typename Iterator, typename ... Iterators>
Function Zip (Function func, Iterator begin,
Iterator end,
Iterators ... iterators)
{
for(;begin != end; ++begin, advance_all(iterators...))
func(*begin, *(iterators)... );
//could also make this a Tuple
return func;
}
使用例：
int main () {
std::vector<int> v1{1,2,3};
std::vector<int> v2{3,2,1};
std::vector<float> v3{1.2,2.4,9.0};
std::vector<float> v4{1.2,2.4,9.0};
Zip (
[](int i,int j,float k,float l){
std::cout << i << " " << j << " " << k << " " << l << std::endl;
},
v1.begin(),v1.end(),v2.begin(),v3.begin(),v4.begin());
}
std :: transform これは簡単にできます：
std::vector<int> a = {1,2,3,4,5};
std::vector<int> b = {1,2,3,4,5};
std::vector<int>c;
std::transform(a.begin(),a.end(), b.begin(),
std::back_inserter(c),
[](const auto& aa, const auto& bb)
{
return aa*bb;
});
for(auto cc:c)
std::cout<<cc<<std::endl;
2番目のシーケンスが短い場合、私の実装はデフォルトの初期化された値を与えているようです。
range-v の場合：
#include <range/v3/all.hpp>
#include <vector>
#include <iostream>
namespace ranges {
template <class T, class U>
std::ostream& operator << (std::ostream& os, common_pair<T, U> const& p)
{
return os << '(' << p.first << ", " << p.second << ')';
}
}
using namespace ranges::v3;
int main()
{
std::vector<int> a {4, 5, 6};
double b[] = {7, 8, 9};
std::cout << view::Zip(a, b) << std::endl;
}
出力：
[（4、7）、（5、8）、（6、9）]
私は独立してこの同じ質問にぶつかり、上記のいずれの構文も好きではありませんでした。そのため、基本的にはBoost Zip_iteratorと同じですが、構文をより美しくするためのマクロがいくつかある短いヘッダーファイルがあります。
https://github.com/cshelton/zipfor
たとえば、次のことができます
vector<int> a {1,2,3};
array<string,3> b {"hello","there","coders"};
zipfor(i,s eachin a,b)
cout << i << " => " << s << endl;
主な構文糖は、各コンテナから要素に名前を付けることができるということです。同じことを行う「mapfor」も含めますが、これはマップ用です（要素の「.first」と「.second」に名前を付けるため）。
// declare a, b
BOOST_FOREACH(boost::tie(a, b), boost::combine(list_of_a, list_of_b)){
// your code here.
}
演算子のオーバーロードが好きな場合、次の3つの可能性があります。最初の2つは、std::pair<>とstd::Tuple<>をそれぞれ反復子として使用しています。 3番目は、これを範囲ベースのforに拡張します。誰もがこれらの演算子の定義を気に入るとは限らないことに注意してください。したがって、これらを別の名前空間に保持し、これらを使用する関数（ファイルではなく）にusing namespaceを含めるのが最善です。
#include <iostream>
#include <utility>
#include <vector>
#include <Tuple>
// put these in namespaces so we don't pollute global
namespace pair_iterators
{
template<typename T1, typename T2>
std::pair<T1, T2> operator++(std::pair<T1, T2>& it)
{
++it.first;
++it.second;
return it;
}
}
namespace Tuple_iterators
{
// you might want to make this generic (via param pack)
template<typename T1, typename T2, typename T3>
auto operator++(std::Tuple<T1, T2, T3>& it)
{
++( std::get<0>( it ) );
++( std::get<1>( it ) );
++( std::get<2>( it ) );
return it;
}
template<typename T1, typename T2, typename T3>
auto operator*(const std::Tuple<T1, T2, T3>& it)
{
return std::tie( *( std::get<0>( it ) ),
*( std::get<1>( it ) ),
*( std::get<2>( it ) ) );
}
// needed due to ADL-only lookup
template<typename... Args>
struct Tuple_c
{
std::Tuple<Args...> containers;
};
template<typename... Args>
auto tie_c( const Args&... args )
{
Tuple_c<Args...> ret = { std::tie(args...) };
return ret;
}
template<typename T1, typename T2, typename T3>
auto begin( const Tuple_c<T1, T2, T3>& c )
{
return std::make_Tuple( std::get<0>( c.containers ).begin(),
std::get<1>( c.containers ).begin(),
std::get<2>( c.containers ).begin() );
}
template<typename T1, typename T2, typename T3>
auto end( const Tuple_c<T1, T2, T3>& c )
{
return std::make_Tuple( std::get<0>( c.containers ).end(),
std::get<1>( c.containers ).end(),
std::get<2>( c.containers ).end() );
}
// implement cbegin(), cend() as needed
}
int main()
{
using namespace pair_iterators;
using namespace Tuple_iterators;
std::vector<double> ds = { 0.0, 0.1, 0.2 };
std::vector<int > is = { 1, 2, 3 };
std::vector<char > cs = { 'a', 'b', 'c' };
// classical, iterator-style using pairs
for( auto its = std::make_pair(ds.begin(), is.begin()),
end = std::make_pair(ds.end(), is.end() ); its != end; ++its )
{
std::cout << "1. " << *(its.first ) + *(its.second) << " " << std::endl;
}
// classical, iterator-style using tuples
for( auto its = std::make_Tuple(ds.begin(), is.begin(), cs.begin()),
end = std::make_Tuple(ds.end(), is.end(), cs.end() ); its != end; ++its )
{
std::cout << "2. " << *(std::get<0>(its)) + *(std::get<1>(its)) << " "
<< *(std::get<2>(its)) << " " << std::endl;
}
// range for using tuples
for( const auto& d_i_c : tie_c( ds, is, cs ) )
{
std::cout << "3. " << std::get<0>(d_i_c) + std::get<1>(d_i_c) << " "
<< std::get<2>(d_i_c) << " " << std::endl;
}
}
C++ 14準拠のコンパイラ（gcc5など）を使用している場合、Ryan Hainingが Zip ライブラリで提供するcppitertoolsを使用できます。
array<int,4> i{{1,2,3,4}};
vector<float> f{1.2,1.4,12.3,4.5,9.9};
vector<string> s{"i","like","apples","alot","dude"};
array<double,5> d{{1.2,1.2,1.2,1.2,1.2}};
for (auto&& e : Zip(i,f,s,d)) {
cout << std::get<0>(e) << ' '
<< std::get<1>(e) << ' '
<< std::get<2>(e) << ' '
<< std::get<3>(e) << '\n';
std::get<1>(e)=2.2f; // modifies the underlying 'f' array
}
C++ストリーム処理ライブラリ の場合、サードパーティのライブラリに依存せず、任意の数のコンテナで動作するソリューションを探していました。私はこの解決策になりました。ブーストを使用する承認済みのソリューションに似ています（コンテナーの長さが等しくない場合、未定義の動作も発生します）
#include <utility>
namespace impl {
template <typename Iter, typename... Iters>
class Zip_iterator {
public:
using value_type = std::Tuple<const typename Iter::value_type&,
const typename Iters::value_type&...>;
Zip_iterator(const Iter &head, const Iters&... tail)
: head_(head), tail_(tail...) { }
value_type operator*() const {
return std::Tuple_cat(std::Tuple<const typename Iter::value_type&>(*head_), *tail_);
}
Zip_iterator& operator++() {
++head_; ++tail_;
return *this;
}
bool operator==(const Zip_iterator &rhs) const {
return head_ == rhs.head_ && tail_ == rhs.tail_;
}
bool operator!=(const Zip_iterator &rhs) const {
return !(*this == rhs);
}
private:
Iter head_;
Zip_iterator<Iters...> tail_;
};
template <typename Iter>
class Zip_iterator<Iter> {
public:
using value_type = std::Tuple<const typename Iter::value_type&>;
Zip_iterator(const Iter &head) : head_(head) { }
value_type operator*() const {
return value_type(*head_);
}
Zip_iterator& operator++() { ++head_; return *this; }
bool operator==(const Zip_iterator &rhs) const { return head_ == rhs.head_; }
bool operator!=(const Zip_iterator &rhs) const { return !(*this == rhs); }
private:
Iter head_;
};
} // namespace impl
template <typename Iter>
class seq {
public:
using iterator = Iter;
seq(const Iter &begin, const Iter &end) : begin_(begin), end_(end) { }
iterator begin() const { return begin_; }
iterator end() const { return end_; }
private:
Iter begin_, end_;
};
/* WARNING: Undefined behavior if iterator lengths are different.
*/
template <typename... Seqs>
seq<impl::Zip_iterator<typename Seqs::iterator...>>
Zip(const Seqs&... seqs) {
return seq<impl::Zip_iterator<typename Seqs::iterator...>>(
impl::Zip_iterator<typename Seqs::iterator...>(std::begin(seqs)...),
impl::Zip_iterator<typename Seqs::iterator...>(std::end(seqs)...));
}
Boost.Iteratorsには Zip_iterator があります（ドキュメントの例）。 range forでは機能しませんが、std::for_eachとラムダを使用できます。