সি ++ 11 এর জন্য সিকোয়েন্স-জিপ ফাংশন?

Question 1

লুপের জন্য নতুন পরিসর-ভিত্তিক আমরা কোডটি লিখতে পারি

for(auto x: Y) {}

কোন আইএমও এক বিশাল উন্নতি (প্রাক্তন হিসাবে)

for(std::vector<int>::iterator x=Y.begin(); x!=Y.end(); ++x) {}

এটি কি পাইথন zipফাংশনের মতো দুটি যুগপত লুপের উপর লুপ করতে ব্যবহৃত হতে পারে ? পাইথনের সাথে অপরিচিত যারা, কোডটি:

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)

Question 2

সতর্কতা: boost::zip_iterator এবং boost::combineবুস্ট ১.6363.০. (২০১ Dec ডিসেম্বর ২)) ইনপুট কনটেইনারগুলির দৈর্ঘ্য একই না হলে (এটি ক্র্যাশ হতে পারে বা শেষের বাইরে যেতে পারে) und

বুস্ট 1.56.0 থেকে শুরু করে (2014 আগস্ট 7) আপনি ব্যবহার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 এ 4
5 8 বি 5
6 9 গ 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);
}

ব্যবহার একই।

Question 3

সুতরাং আমি বিরক্ত হওয়ার আগে আমি এই জিপটি লিখেছিলাম, আমি এটি পোস্ট করার সিদ্ধান্ত নিয়েছিলাম কারণ এটি অন্যদের তুলনায় আলাদা যে এটি বস্ট ব্যবহার করে না এবং এটি সি ++ স্টেডলিবের মতো দেখায়।

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());
}

Question 4

std :: রূপান্তর তুচ্ছভাবে এটি করতে পারে:

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;

দ্বিতীয় ক্রমটি যদি ছোট হয় তবে আমার বাস্তবায়নটি ডিফল্ট প্রাথমিক মানের মান দিচ্ছে বলে মনে হচ্ছে।

Question 5

আপনি এর ভিত্তিতে একটি সমাধান ব্যবহার করতে পারেন boost::zip_iterator। আপনার ধারকগুলিতে রেফারেন্স বজায় রাখার জন্য একটি ফোনে কনটেইনার শ্রেণি তৈরি করুন এবং যা সদস্য এবং ফাংশন zip_iteratorথেকে ফিরে আসে । এখন আপনি লিখতে পারেনbeginend

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);
}

আমি পাঠকের কাছে একটি দুর্দান্ত অনুশীলন হিসাবে বৈকল্পিক সংস্করণটি রেখেছি leave

Question 6

এমন <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

Question 7

সঙ্গে পরিসীমা-V3 :

#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)]

Question 8

আমি স্বাধীনভাবে এই একই প্রশ্নে দৌড়েছি এবং উপরের কোনওটির বাক্য গঠনটি পছন্দ করি না। সুতরাং, আমার কাছে একটি সংক্ষিপ্ত শিরোনাম ফাইল রয়েছে যা মূলত বুস্ট জিপ_এটিরেটর হিসাবে একই রকম হয় তবে আমার কাছে সিনট্যাক্সটিকে আরও স্বচ্ছল করে তুলতে কয়েকটি ম্যাক্রো রয়েছে:

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;

মূল সিনট্যাকটিক চিনিটি হ'ল আমি প্রতিটি পাত্রে থাকা উপাদানগুলির নাম দিতে পারি। আমি একটি "ম্যাপফোর" অন্তর্ভুক্ত করেছি যা একই কাজ করে তবে মানচিত্রের জন্য (উপাদানটির ".প্রথম" এবং ".সেকেন্ড" নামকরণ করতে)।

Question 9

// declare a, b
BOOST_FOREACH(boost::tie(a, b), boost::combine(list_of_a, list_of_b)){
    // your code here.
}

Question 10

আপনি যদি অপারেটর ওভারলোডিং পছন্দ করেন তবে এখানে তিনটি সম্ভাবনা রয়েছে। প্রথম দুটি যথাক্রমে পুনরাবৃত্তকারী হিসাবে std::pair<>এবং ব্যবহার করছে std::tuple<>; তৃতীয়টি এটি পরিসীমা ভিত্তিক প্রসারিত করে 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;
    }
}

Question 11

আমি লিখছি এমন একটি সি ++ স্ট্রিম প্রসেসিং লাইব্রেরির জন্য আমি এমন একটি সমাধান খুঁজছিলাম যা তৃতীয় পক্ষের লাইব্রেরিতে নির্ভর করে না এবং একটি নির্বিচার সংখ্যক পাত্রে কাজ করে। আমি এই সমাধান দিয়ে শেষ। এটি গ্রহণযোগ্য সমাধানের মতো যা বুস্ট ব্যবহার করে (এবং ধারকের দৈর্ঘ্য সমান না হলে অপরিজ্ঞাত আচরণেও ফলাফল আসে)

#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)...));
}

Question 12

আপনার যদি সি ++ 14 কমপ্লায়েন্ট কম্পাইলার থাকে (যেমন, জিসিসি 5) আপনি লাইব্রেরিতে রায়ান হেইনিংয়ের 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
}

Question 13

বুস্ট.আইট্রেটারগুলির zip_iteratorআপনি ব্যবহার করতে পারেন (উদাহরণস্বরূপ ডক্সে )। এটি এর জন্য পরিসীমা নিয়ে কাজ করবে না, তবে আপনি std::for_eachএবং ল্যাম্বডা ব্যবহার করতে পারেন ।

Question 14

এখানে একটি সাধারণ সংস্করণ যা বুস্ট করার প্রয়োজন হয় না। এটি বিশেষভাবে দক্ষ হবে না কারণ এটি অস্থায়ী মান তৈরি করে এবং এটি তালিকাগুলি ব্যতীত অন্য ধারকগুলির উপরে সাধারণকরণ করে না, তবে এর কোনও নির্ভরতা নেই এবং এটি জিপ করার জন্য সবচেয়ে সাধারণ ক্ষেত্রে সমাধান করে।

template<class L, class R>
std::list< std::pair<L,R> >  zip(std::list<L> left, std::list<R> right)
{
auto l = left.begin();
auto r = right.begin();
std::list< std::pair<L,R> > result;
  while( l!=left.end() && r!=right.end() )
    result.push_back( std::pair<L,R>( *(l++), *(r++) ) );
  return result;
}

যদিও অন্যান্য সংস্করণগুলি আরও নমনীয়, তবে প্রায়শই একটি তালিকা অপারেটর ব্যবহারের বিন্দুটি একটি সহজ ওয়ানলাইনার তৈরি করে। সাধারণ সংস্করণটি সহজ benefit