Как с помощью C ++ избежать циклов for с условием «if» внутри них?

Почти со всем кодом, который я пишу, я часто сталкиваюсь с проблемами сокращения наборов в коллекциях, которые в конечном итоге заканчиваются наивными условиями «если» внутри них. Вот простой пример:

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

С функциональными языками я могу решить проблему, уменьшив коллекцию до другой коллекции (легко), а затем выполнить все операции с моим сокращенным набором. В псевдокоде:

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

И в других вариантах C, таких как C #, я мог бы сократить с помощью предложения where, например

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

Или лучше (по крайней мере, на мой взгляд)

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

По общему признанию, я много смешиваю парадигмы и стиль, основанный на субъективном мнении, но я не могу не чувствовать, что мне не хватает чего-то действительно фундаментального, что позволило бы мне использовать этот предпочтительный метод с C ++. Может ли кто-нибудь просветить меня?

ИМХО более прямолинейно и читабельно использовать цикл for с if внутри него. Однако, если вас это раздражает, вы можете использовать такой, for_each_ifкак показано ниже:

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

Вариант использования:

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

Живая демонстрация

Boost предоставляет диапазоны, которые можно использовать для. Диапазоны имеют то преимущество , что они не копируют , лежащие в основе структуры данных, они просто обеспечивают «вид» (то есть begin(), end()для диапазона и operator++(), operator==()для итератора). Это может вас заинтересовать: 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;
    }
}

Вместо создания нового алгоритма, как это делает принятый ответ, вы можете использовать существующий с функцией, которая применяет условие:

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

Или, если вам действительно нужен новый алгоритм, по крайней мере, используйте его повторно for_eachвместо дублирования логики итерации:

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

Идея избежать

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

конструкции как антипаттерн слишком широки.

Совершенно нормально обрабатывать несколько элементов, которые соответствуют определенному выражению изнутри цикла, и код не может быть намного яснее этого. Если обработка становится слишком большой и не помещается на экране, это хороший повод для использования подпрограммы, но все же условное выражение лучше всего помещать внутри цикла, т. Е.

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

намного предпочтительнее

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

Он становится антипаттерном, когда будет соответствовать только один элемент, потому что тогда будет проще сначала найти элемент и выполнить обработку вне цикла.

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

является крайним и очевидным примером этого. Более тонким и, следовательно, более распространенным является заводской шаблон, например

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

Это трудно прочитать, потому что не очевидно, что основной код будет выполнен только один раз. В этом случае лучше разделить поиск:

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

ifВнутри a все еще есть for, но из контекста становится ясно, что он делает, нет необходимости изменять этот код, если только поиск не изменится (например, на a map), и сразу становится ясно, что create_object()вызывается только один раз, потому что это не внутри петли.

Вот небольшая относительно минимальная filterфункция.

Требуется предикат. Он возвращает объект функции, который принимает итерацию.

Он возвращает итерацию, которую можно использовать в for(:)цикле.

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

Я пошел короткими путями. Настоящая библиотека должна создавать настоящие итераторы, а не for(:)те псевдофасады, которые я делал.

На момент использования это выглядит так:

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

что довольно приятно, и печатает

1
3
5

Живой пример .

Существует предлагаемое дополнение к C ++ под названием Rangesv3, которое делает такие вещи и многое другое. boostтакже доступны диапазоны фильтров / итераторы. У boost также есть помощники, которые делают написание вышеупомянутого намного короче.

Один стиль, который используется достаточно, чтобы упомянуть, но еще не упоминался, это:

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

  DoStuff();
}

Преимущества:

• Не меняет уровень отступа DoStuff();при увеличении сложности условия. По логике, он DoStuff();должен быть на верхнем уровне forцикла, и это так.
• Сразу становится ясно , что цикл перебирает SOMETHINGс коллекцией, не требуя от читателя , чтобы убедиться , что нет ничего после закрытия }этого ifблока.
• Не требует никаких библиотек, вспомогательных макросов или функций.

Недостатки:

• continue, как и другие операторы управления потоком, неправильно используется таким образом, что приводит к настолько сложному для понимания коду, что некоторые люди выступают против их любого использования: существует допустимый стиль кодирования, которому некоторые следуют, который избегает continue, который избегает, breakкроме в switch, что позволяет избежать, returnкроме как в конце функции.

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

forДля меня это очень похоже на понимание C ++ . Тебе?

Если DoStuff () будет как-то зависеть от i в будущем, я бы предложил этот гарантированный вариант битовой маскировки без ветвлений.

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 - это любая функция, выполняющая подсчет населения (количество бит = 1). Будет некоторая свобода устанавливать более сложные ограничения с i и их соседями. Если в этом нет необходимости, мы можем разделить внутренний цикл и переделать внешний цикл.

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

за которым следует

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

Кроме того, если вам не нужно переупорядочивать коллекцию, std :: partition стоит недорого.

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

Я в восторге от сложности вышеуказанных решений. Я собирался предложить простой, #define foreach(a,b,c,d) for(a; b; c)if(d)но у него есть несколько очевидных недостатков, например, вы должны помнить, что в вашем цикле нужно использовать запятые вместо точки с запятой, и вы не можете использовать оператор запятой в aили 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;
}

Другое решение в случае, если i: s важны. Он формирует список, который заполняет индексы, для которых вызывается doStuff (). Опять же, главное - избежать разветвления и обменять его на конвейерные арифметические затраты.

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.

«Магическая» линия - это линия загрузки буфера, которая арифметически вычисляет, нужно ли сохранять значение и оставаться в позиции или подсчитывать позицию и добавлять значение. Поэтому мы меняем потенциальную ветвь на некоторую логику и арифметику и, возможно, на некоторые попадания в кеш. Типичный сценарий, когда это было бы полезно, - если doStuff () выполняет небольшой объем конвейерных вычислений, и любая ветвь между вызовами может прервать эти конвейеры.

Затем просто переберите буфер и запускайте doStuff (), пока не дойдете до cnt. На этот раз у нас будет текущий i, сохраненный в буфере, поэтому мы можем использовать его в вызове doStuff (), если нам понадобится.

Можно описать ваш шаблон кода как применение некоторой функции к подмножеству диапазона, или, другими словами: применение его к результату применения фильтра ко всему диапазону.

Этого можно достичь самым простым способом с помощью библиотеки Эрика Нейблера range -v3 ; хотя это немного раздражает, потому что вы хотите работать с индексами:

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

Но если вы готовы отказаться от индексов, вы получите:

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

что приятнее ИМХО.

PS - Библиотека диапазонов в основном входит в стандарт C ++ в C ++ 20.

Упомяну только Майка Эктона, он обязательно скажет:

Если вам нужно это сделать, у вас проблемы с вашими данными. Сортируйте свои данные!