İçlerinde "if" koşulu olan "for" döngülerini C ++ ile nasıl önleyebilirim?

Neredeyse yazdığım tüm kodlarla, genellikle koleksiyonlarda, sonuçta içlerinde saf "eğer" koşullarıyla sonuçlanan set azaltma problemleriyle uğraşıyorum. İşte basit bir örnek:

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

İşlevsel dillerle, koleksiyonu başka bir koleksiyona indirgeyerek (kolayca) sorunu çözebilir ve ardından tüm işlemleri küçültülmüş setimde gerçekleştirebilirim. Sözde kodda:

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

Ve C # gibi diğer C değişkenlerinde, bir where cümlesiyle azaltabilirim

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

Ya da daha iyisi (en azından gözlerime)

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

Kuşkusuz, çok fazla paradigma karışımı ve öznel / fikir temelli stil yapıyorum, ancak yardım edemem ama bu tercih edilen tekniği C ++ ile kullanmama izin verebilecek gerçekten temel bir şeyi kaçırdığımı hissediyorum. Biri beni aydınlatabilir mi?

IMHO, içinde if ile bir for döngüsü kullanmak daha basit ve daha okunaklı. Ancak, bu sizin için can sıkıcıysa, for_each_ifaşağıdaki gibi bir tane kullanabilirsiniz :

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

Canlı Demo

Boost, w / aralık tabanlı olarak kullanılabilecek aralıklar sağlar. Aralıklar bunlar temel veri yapısı kopyalamazsanız bu, bunlar sadece bir 'bakış' avantajına sahiptir (olduğundan, begin(), end()aralığı için ve operator++(), operator==()yineleyici için). Bu ilginizi çekebilir: 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;
    }
}

Kabul edilen yanıtın yaptığı gibi yeni bir algoritma oluşturmak yerine, koşulu uygulayan bir işlevle mevcut bir algoritmayı kullanabilirsiniz:

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

Veya gerçekten yeni bir algoritma istiyorsanız for_each, yineleme mantığını kopyalamak yerine en azından orada yeniden kullanın:

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

Kaçınma fikri

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

bir anti-model olarak yapılar çok geniştir.

Bir döngünün içinden belirli bir ifadeyle eşleşen birden çok öğeyi işlemek tamamen iyidir ve kod bundan daha net olamaz. İşlem ekrana sığmayacak kadar büyürse, bu bir alt yordam kullanmak için iyi bir nedendir, ancak yine de koşullu en iyi döngü içine yerleştirilir, yani

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

büyük ölçüde tercih edilir

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

Sadece bir eleman eşleştiğinde bir anti-model haline gelir, çünkü o zaman önce elemanı aramak ve işlemi döngünün dışında gerçekleştirmek daha net olacaktır.

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

bunun aşırı ve açık bir örneğidir. Daha incelikli ve dolayısıyla daha yaygın olan bir fabrika modelidir.

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

Bunu okumak zordur, çünkü gövde kodunun yalnızca bir kez çalıştırılacağı açık değildir. Bu durumda, aramayı ayırmak daha iyi olacaktır:

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

Hala bir ifvardır for, ancak bağlamdan ne yaptığı netleşir, arama değişmedikçe (örneğin a'ya) bu kodu değiştirmeye gerek yoktur mapve bunun create_object()yalnızca bir kez çağrıldığı hemen açıktır , çünkü bir döngü içinde değil.

İşte hızlı nispeten minimum filter işlev.

Bir yüklem alır. Yinelenebilir alan bir işlev nesnesi döndürür.

Bir for(:)döngüde kullanılabilen bir yinelenebilir döndürür .

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

Kestirmeler yaptım. Gerçek bir kütüphane, for(:)benim yaptığım niteleyici sözde fascades değil, gerçek yineleyiciler yapmalıdır.

Kullanım noktasında şuna benzer:

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

bu oldukça güzel ve baskılar

1
3
5

Canlı örnek .

Bu tür şeyleri ve daha fazlasını yapan Rangesv3 adlı C ++ 'ya önerilen bir ekleme var. boostayrıca filtre aralıkları / yineleyiciler de mevcuttur. boost ayrıca yukarıdakileri yazmayı çok daha kısa hale getiren yardımcılara da sahiptir.

Bahsetmek için yeterince alışan, ancak henüz bahsedilmeyen bir stil:

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

  DoStuff();
}

Avantajları:

• DoStuff();Koşul karmaşıklığı arttığında girinti seviyesini değiştirmez . Mantıksal DoStuff();olarak, en üst düzeyde olmalıdırfor döngünün ve öyle.
• Hemen o temizlemek yapar üzerinde döngü yinelenir SOMETHINGtoplama s, kapanış sonrasında hiçbir şey olmadığını doğrulamak için okuyucu gerektirmeden }ait ifbloğu.
• Herhangi bir kitaplık veya yardımcı makro veya işlev gerektirmez.

Dezavantajları:

• continue, diğer akış kontrol ifadeleri gibi, takip edilmesi zor koda yol açan şekillerde kötüye kullanılır ki, bazı insanlar bunların herhangi bir şekilde kullanılmasına karşı çıkarlar : Bazılarının takip ettiği continue, breakdiğerlerinden kaçınan geçerli bir kodlama stili vardır. bir de switch, bu engeller returnbir işlevi sonunda başka.

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

forBana C ++ 'ya özgü bir anlayışa benziyor . Sana?

DoStuff (), gelecekte bir şekilde i'ye bağımlı olacaksa, bu garantili dalsız bit maskeleme varyantını öneririm.

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

Popcount, popülasyon sayımı yapan herhangi bir işlevdir (bit sayısı = 1). İ ve komşuları ile daha gelişmiş kısıtlamalar koyma özgürlüğü olacak. Buna gerek yoksa, iç halkayı soyabilir ve dış halkayı yeniden yapabiliriz.

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

ardından bir

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

Ayrıca, koleksiyonu yeniden sıralamayı önemsemiyorsanız, std :: partition ucuzdur.

#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
}

Yukarıdaki çözümlerin karmaşıklığına hayran kaldım. Basit bir öneride #define foreach(a,b,c,d) for(a; b; c)if(d)bulunacaktım, ancak birkaç açık eksikliği var, örneğin, döngünüzde noktalı virgül yerine virgül kullanmayı unutmamalısınız ve aveya içinde virgül operatörünü kullanamazsınız 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;
}

İ: lerin önemli olması durumunda başka bir çözüm. Bu, doStuff () 'ı çağırmak için dizinleri dolduran bir liste oluşturur. Bir kez daha ana nokta, dallanmadan kaçınmak ve bunu boru hattına bağlanabilir aritmetik maliyetlerle ticaret yapmaktır.

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.

"Büyülü" çizgi, değeri korumak ve pozisyonda kalmak veya pozisyonu saymak ve değer eklemek için aritmetik olarak hesaplayan tampon yükleme çizgisidir. Bu yüzden, bazı mantık ve aritmetik ve belki de bazı önbellek isabetleri için potansiyel bir dalı değiştiriyoruz. Bunun yararlı olacağı tipik bir senaryo, doStuff () 'ın az miktarda ardışık düzenlenebilir hesaplama yapması ve çağrılar arasındaki herhangi bir dalın bu ardışık düzeni kesebilmesidir.

Sonra tampon üzerinde döngü yapın ve cnt'ye ulaşana kadar doStuff () çalıştırın. Bu sefer arabellekte depolanan mevcut i'ye sahip olacağız, böylece gerekirse doStuff () çağrısında kullanabiliriz.

Kod modelinizi, bir aralığın bir alt kümesine bir işlev uygulamak veya başka bir deyişle, tüm aralığa bir filtre uygulama sonucuna uygulamak olarak tanımlanabilir.

Bu, Eric Neibler'in serileri-v3 kitaplığı ile en basit şekilde elde edilebilir ; biraz göze batan bir şey olsa da, endekslerle çalışmak istiyorsun:

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

Ancak endekslerden vazgeçmeye istekliysen, şunları elde edersin:

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

hangi IMHO daha güzel.

Not - Aralık kitaplığı çoğunlukla C ++ 20'de C ++ standardına giriyor.

Sadece Mike Acton'dan bahsedeceğim, kesinlikle şöyle derdi:

Bunu yapmak zorunda kalırsanız, verilerinizle ilgili bir sorununuz var. Verilerinizi sıralayın!