Bagaimana cara menghindari loop "for" dengan kondisi "if" di dalamnya dengan C ++?

Dengan hampir semua kode yang saya tulis, saya sering berurusan dengan masalah pengurangan set pada koleksi yang pada akhirnya berakhir dengan kondisi "jika" yang naif di dalamnya. Berikut contoh sederhananya:

for(int i=0; i<myCollection.size(); i++)
{
     if (myCollection[i] == SOMETHING)
     {
           DoStuff();
     }
}

Dengan bahasa fungsional, saya dapat memecahkan masalah dengan mengurangi koleksi ke koleksi lain (dengan mudah) dan kemudian melakukan semua operasi pada set saya yang dikurangi. Dalam pseudocode:

newCollection <- myCollection where <x=true
map DoStuff newCollection

Dan pada varian C lainnya, seperti C #, saya bisa menguranginya dengan klausa where

foreach (var x in myCollection.Where(c=> c == SOMETHING)) 
{
   DoStuff();
}

Atau lebih baik (setidaknya di mataku)

myCollection.Where(c=>c == Something).ToList().ForEach(d=> DoStuff(d));

Memang, saya melakukan banyak pencampuran paradigma dan gaya berbasis opini / subjektif, tetapi saya merasa bahwa saya kehilangan sesuatu yang sangat mendasar yang memungkinkan saya menggunakan teknik yang disukai ini dengan C ++. Bisakah seseorang mencerahkan saya?

IMHO itu lebih lurus ke depan dan lebih mudah dibaca menggunakan for loop dengan if di dalamnya. Namun, jika ini mengganggu Anda, Anda dapat menggunakan cara for_each_ifseperti di bawah ini:

template<typename Iter, typename Pred, typename Op> 
void for_each_if(Iter first, Iter last, Pred p, Op op) {
  while(first != last) {
    if (p(*first)) op(*first);
    ++first;
  }
}

Usecase:

std::vector<int> v {10, 2, 10, 3};
for_each_if(v.begin(), v.end(), [](int i){ return i > 5; }, [](int &i){ ++i; });

Demo Langsung

Boost menyediakan rentang yang dapat digunakan dengan berbasis rentang. Rentang memiliki keuntungan bahwa mereka tidak menyalin struktur data yang mendasari, mereka hanya menyediakan 'tampilan' (yaitu begin(), end()untuk rentang dan operator++(), operator==()untuk iterator). Ini mungkin menarik minat Anda: http://www.boost.org/libs/range/doc/html/range/reference/adaptors/reference/filtered.html

#include <boost/range/adaptor/filtered.hpp>
#include <iostream>
#include <vector>

struct is_even
{
    bool operator()( int x ) const { return x % 2 == 0; }
};

int main(int argc, const char* argv[])
{
    using namespace boost::adaptors;

    std::vector<int> myCollection{1,2,3,4,5,6,7,8,9};

    for( int i: myCollection | filtered( is_even() ) )
    {
        std::cout << i;
    }
}

Daripada membuat algoritme baru, seperti jawaban yang diterima, Anda dapat menggunakan algoritme yang sudah ada dengan fungsi yang menerapkan kondisi:

std::for_each(first, last, [](auto&& x){ if (cond(x)) { ... } });

Atau jika Anda benar-benar menginginkan algoritme baru, setidaknya gunakan kembali algoritme tersebut for_eachdaripada menduplikasi logika iterasi:

template<typename Iter, typename Pred, typename Op> 
  void
  for_each_if(Iter first, Iter last, Pred p, Op op) {
    std::for_each(first, last, [&](auto& x) { if (p(x)) op(x); });
  }

Ide untuk menghindari

for(...)
    if(...)

konstruksi sebagai antipattern terlalu luas.

Tidak masalah untuk memproses beberapa item yang cocok dengan ekspresi tertentu dari dalam loop, dan kode tidak bisa lebih jelas dari itu. Jika pemrosesan menjadi terlalu besar untuk muat di layar, itu adalah alasan yang baik untuk menggunakan subrutin, tetapi tetap saja kondisional paling baik ditempatkan di dalam loop, yaitu

for(...)
    if(...)
        do_process(...);

jauh lebih disukai daripada

for(...)
    maybe_process(...);

Ini menjadi antipattern ketika hanya satu elemen yang cocok, karena akan lebih jelas untuk mencari elemen terlebih dahulu, dan melakukan pemrosesan di luar loop.

for(int i = 0; i < size; ++i)
    if(i == 5)

adalah contoh ekstrim dan jelas dari ini. Lebih halus, dan dengan demikian lebih umum, adalah pola pabrik seperti

for(creator &c : creators)
    if(c.name == requested_name)
    {
        unique_ptr<object> obj = c.create_object();
        obj.owner = this;
        return std::move(obj);
    }

Ini sulit dibaca, karena tidak jelas bahwa kode body hanya akan dijalankan satu kali. Dalam kasus ini, akan lebih baik untuk memisahkan pencarian:

creator &lookup(string const &requested_name)
{
    for(creator &c : creators)
        if(c.name == requested_name)
            return c;
}

creator &c = lookup(requested_name);
unique_ptr obj = c.create_object();

Masih ada ifdalam a for, tetapi dari konteksnya menjadi jelas apa yang dilakukannya, tidak perlu mengubah kode ini kecuali pencarian berubah (mis. Menjadi a map), dan segera jelas bahwa create_object()hanya dipanggil sekali, karena itu tidak dalam satu lingkaran.

Berikut adalah fungsi cepat yang relatif minimal filter.

Itu butuh predikat. Ini mengembalikan objek fungsi yang membutuhkan iterable.

Ini mengembalikan iterable yang dapat digunakan dalam satu for(:)lingkaran.

template<class It>
struct range_t {
  It b, e;
  It begin() const { return b; }
  It end() const { return e; }
  bool empty() const { return begin()==end(); }
};
template<class It>
range_t<It> range( It b, It e ) { return {std::move(b), std::move(e)}; }

template<class It, class F>
struct filter_helper:range_t<It> {
  F f;
  void advance() {
    while(true) {
      (range_t<It>&)*this = range( std::next(this->begin()), this->end() );
      if (this->empty())
        return;
      if (f(*this->begin()))
        return;
    }
  }
  filter_helper(range_t<It> r, F fin):
    range_t<It>(r), f(std::move(fin))
  {
      while(true)
      {
          if (this->empty()) return;
          if (f(*this->begin())) return;
          (range_t<It>&)*this = range( std::next(this->begin()), this->end() );
      }
  }
};

template<class It, class F>
struct filter_psuedo_iterator {
  using iterator_category=std::input_iterator_tag;
  filter_helper<It, F>* helper = nullptr;
  bool m_is_end = true;
  bool is_end() const {
    return m_is_end || !helper || helper->empty();
  }

  void operator++() {
    helper->advance();
  }
  typename std::iterator_traits<It>::reference
  operator*() const {
    return *(helper->begin());
  }
  It base() const {
      if (!helper) return {};
      if (is_end()) return helper->end();
      return helper->begin();
  }
  friend bool operator==(filter_psuedo_iterator const& lhs, filter_psuedo_iterator const& rhs) {
    if (lhs.is_end() && rhs.is_end()) return true;
    if (lhs.is_end() || rhs.is_end()) return false;
    return lhs.helper->begin() == rhs.helper->begin();
  }
  friend bool operator!=(filter_psuedo_iterator const& lhs, filter_psuedo_iterator const& rhs) {
    return !(lhs==rhs);
  }
};
template<class It, class F>
struct filter_range:
  private filter_helper<It, F>,
  range_t<filter_psuedo_iterator<It, F>>
{
  using helper=filter_helper<It, F>;
  using range=range_t<filter_psuedo_iterator<It, F>>;

  using range::begin; using range::end; using range::empty;

  filter_range( range_t<It> r, F f ):
    helper{{r}, std::forward<F>(f)},
    range{ {this, false}, {this, true} }
  {}
};

template<class F>
auto filter( F&& f ) {
    return [f=std::forward<F>(f)](auto&& r)
    {
        using std::begin; using std::end;
        using iterator = decltype(begin(r));
        return filter_range<iterator, std::decay_t<decltype(f)>>{
            range(begin(r), end(r)), f
        };
    };
};

Saya mengambil jalan pintas. Perpustakaan yang sebenarnya harus membuat iterator yang nyata, bukan for(:)pseudo-fasad yang memenuhi syarat seperti yang saya lakukan.

Saat digunakan, tampilannya seperti ini:

int main()
{
  std::vector<int> test = {1,2,3,4,5};
  for( auto i: filter([](auto x){return x%2;})( test ) )
    std::cout << i << '\n';
}

yang cukup bagus, dan cetakan

1
3
5

Contoh langsung .

Ada tambahan yang diusulkan untuk C ++ yang disebut Rangesv3 yang melakukan hal semacam ini dan banyak lagi. boostjuga memiliki rentang filter / iterator yang tersedia. boost juga memiliki pembantu yang membuat tulisan di atas jauh lebih singkat.

Salah satu gaya yang cukup sering digunakan untuk disebutkan, tetapi belum disebutkan, adalah:

for(int i=0; i<myCollection.size(); i++) {
  if (myCollection[i] != SOMETHING)
    continue;

  DoStuff();
}

Keuntungan:

• Tidak mengubah tingkat indentasi DoStuff();saat kompleksitas kondisi meningkat. Logikanya, DoStuff();harus di tingkat atas dari forloop, dan itu.
• Segera membuat jelas bahwa iterates loop atas SOMETHINGs koleksi, tanpa memerlukan pembaca untuk memverifikasi bahwa tidak ada setelah penutupan }dari ifblok.
• Tidak memerlukan pustaka atau makro pembantu atau fungsi apa pun.

Kekurangan:

• continue, Seperti pernyataan kontrol aliran lainnya, akan disalahgunakan dengan cara-cara yang mengarah pada kode-to-follow keras sehingga beberapa orang menentang setiap penggunaan mereka: ada gaya valid coding bahwa beberapa tindak yang menghindari continue, yang menghindari breakselain di a switch, yang menghindari returnselain di akhir fungsi.

for(auto const &x: myCollection) if(x == something) doStuff();

Sepertinya forpemahaman khusus C ++ bagi saya. Kepadamu?

Jika DoStuff () akan bergantung pada saya entah bagaimana di masa depan maka saya akan mengusulkan varian bit-masking bebas cabang yang dijamin ini.

unsigned int times = 0;
const int kSize = sizeof(unsigned int)*8;
for(int i = 0; i < myCollection.size()/kSize; i++){
  unsigned int mask = 0;
  for (int j = 0; j<kSize; j++){
    mask |= (myCollection[i*kSize+j]==SOMETHING) << j;
  }
  times+=popcount(mask);
}

for(int i=0;i<times;i++)
   DoStuff();

Dimana popcount adalah fungsi yang melakukan penghitungan populasi (menghitung jumlah bit = 1). Akan ada kebebasan untuk menempatkan batasan yang lebih maju dengan saya dan tetangga mereka. Jika itu tidak diperlukan, kita dapat menghapus loop dalam dan membuat ulang loop luar

for(int i = 0; i < myCollection.size(); i++)
  times += (myCollection[i]==SOMETHING);

diikuti dengan a

for(int i=0;i<times;i++)
   DoStuff();

Selain itu, jika Anda tidak peduli menata ulang collection, std :: partition adalah murah.

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>

void DoStuff(int i)
{
    std::cout << i << '\n';
}

int main()
{
    using namespace std::placeholders;

    std::vector<int> v {1, 2, 5, 0, 9, 5, 5};
    const int SOMETHING = 5;

    std::for_each(v.begin(),
                  std::partition(v.begin(), v.end(),
                                 std::bind(std::equal_to<int> {}, _1, SOMETHING)), // some condition
                  DoStuff); // action
}

Saya kagum dengan kompleksitas solusi di atas. Saya akan menyarankan yang sederhana #define foreach(a,b,c,d) for(a; b; c)if(d)tetapi memiliki beberapa defisit yang jelas, misalnya, Anda harus ingat untuk menggunakan koma alih-alih titik koma dalam lingkaran Anda, dan Anda tidak dapat menggunakan operator koma di aatau c.

#include <list>
#include <iostream>

using namespace std; 

#define foreach(a,b,c,d) for(a; b; c)if(d)

int main(){
  list<int> a;

  for(int i=0; i<10; i++)
    a.push_back(i);

  for(auto i=a.begin(); i!=a.end(); i++)
    if((*i)&1)
      cout << *i << ' ';
  cout << endl;

  foreach(auto i=a.begin(), i!=a.end(), i++, (*i)&1)
    cout << *i << ' ';
  cout << endl;

  return 0;
}

Solusi lain jika i: ​​s penting. Yang ini membuat daftar yang mengisi indeks yang akan dipanggil doStuff (). Sekali lagi, poin utamanya adalah menghindari percabangan dan menukarnya dengan biaya aritmatika yang dapat dialirkan.

int buffer[someSafeSize];
int cnt = 0; // counter to keep track where we are in list.
for( int i = 0; i < container.size(); i++ ){
   int lDecision = (container[i] == SOMETHING);
   buffer[cnt] = lDecision*i + (1-lDecision)*buffer[cnt];
   cnt += lDecision;
}

for( int i=0; i<cnt; i++ )
   doStuff(buffer[i]); // now we could pass the index or a pointer as an argument.

Garis "ajaib" adalah garis pemuatan penyangga yang secara aritmatik menghitung apakah untuk mempertahankan nilai dan tetap pada posisinya atau untuk menghitung posisi dan menambah nilai. Jadi kami menukar cabang potensial untuk beberapa logika dan aritmatika dan mungkin beberapa cache hits. Skenario umum saat ini akan berguna adalah jika doStuff () melakukan sedikit penghitungan pipelineable dan setiap cabang di antara panggilan dapat mengganggu pipeline tersebut.

Kemudian lakukan loop di atas buffer dan jalankan doStuff () sampai kita mencapai cnt. Kali ini kita akan menyimpan arus i di buffer sehingga kita dapat menggunakannya dalam panggilan ke doStuff () jika diperlukan.

Seseorang dapat mendeskripsikan pola kode Anda sebagai menerapkan beberapa fungsi ke subset rentang, atau dengan kata lain: menerapkannya ke hasil penerapan filter ke seluruh rentang.

Ini dapat dicapai dengan cara yang paling mudah dengan pustaka range-v3 Eric Neibler ; meskipun sedikit merusak pemandangan, karena Anda ingin bekerja dengan indeks:

using namespace ranges;
auto mycollection_has_something = 
    [&](std::size_t i) { return myCollection[i] == SOMETHING };
auto filtered_view = 
    views::iota(std::size_t{0}, myCollection.size()) | 
    views::filter(mycollection_has_something);
for (auto i : filtered_view) { DoStuff(); }

Tetapi jika Anda bersedia melepaskan indeks, Anda akan mendapatkan:

auto is_something = [&SOMETHING](const decltype(SOMETHING)& x) { return x == SOMETHING };
auto filtered_collection = myCollection | views::filter(is_something);
for (const auto& x : filtered_collection) { DoStuff(); }

yang IMHO lebih bagus.

PS - Pustaka rentang sebagian besar menggunakan standar C ++ di C ++ 20.

Saya hanya akan menyebut Mike Acton, dia pasti akan berkata:

Jika Anda harus melakukan itu, Anda memiliki masalah dengan data Anda. Sortir data Anda!